Zahlreiche Rechtschreibfehler korrigiert

ArrayExperimente.java

@@ -1,17 +1,17 @@
 
 /**
- * Uebungen mit Arrays. 
+ * Übungen mit Arrays. 
  * 
- * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchfuehren.
+ * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchführen.
  * 
- * Du kannst deine Loesungen mit der beigefuegten Testklasse automatisch 
+ * Du kannst deine Lösungen mit der beigefügten Testklasse automatisch 
- * ueberpruefen
+ * überprüfen
  *   - Klicke mit der rechten Maustaste auf die ArrayExperimenteTest (grün) 
  *     -> "Alles Testen" 
  *   - Sobald du glaubst, eine Funktion fertig programmiert zu haben, 
- *     startest du die Tests und ueberzeugst dich im Testergebnisfenster, 
+ *     startest du die Tests und überzeugst dich im Testergebnisfenster, 
- *     dass der Test fuer diese Funktion erfolgreich durchgelaufen ist.
+ *     dass der Test für diese Funktion erfolgreich durchgelaufen ist.
- *   - Falls er fehlschlaegt, kannst du dort auf den entsprechenden Test klicken
+ *   - Falls er fehlschlägt, kannst du dort auf den entsprechenden Test klicken
  *     und nachschauen, was genau fehlgeschlagen ist.
  *     
  */
@@ -21,7 +21,7 @@ public class ArrayExperimente
     public static int nochnArray[]= new int[] {20,21,22,23,24,25,26};
 
     /**
-     * Gibt das uebergebene Array auf der Konsole aus.
+     * Gibt das übergebene Array auf der Konsole aus.
      * @param array, das Array, das ausgegeben werden soll.
      */
     public static void arrayAusgeben(int[] array)
@@ -68,7 +68,7 @@ public class ArrayExperimente
     
     /**
      * Der Funktion wird ein Array übergeben.
-     * Die Funktion erhoeht nun jeden Eintrag um eins.
+     * Die Funktion erhöht nun jeden Eintrag um eins.
      * Es wird kein neues Array angelegt.
      * @param array Zu manipulierendes Array. Es darf nicht leer sein.    
      */
@@ -81,10 +81,10 @@ public class ArrayExperimente
     
     
     /**
-     * Die Funktion erhoeht im urspruenglichen Array jeden Eintrag um "zuschlag".
+     * Die Funktion erhöht im ursprünglichen Array jeden Eintrag um einen "zuschlag".
      * Es wird kein neues Array angelegt.
      * @param array Zu manipulierendes Array. Es darf nicht leer sein.    
-     * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazuaddiert.
+     * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazu addiert.
      */
     public static void addiereJeweilsD(int[] array, int zuschlag)
     {
@@ -94,7 +94,7 @@ public class ArrayExperimente
     
     
     /**
-     * Ermittelt die Summe ueber alle Arrayelemente.
+     * Ermittelt die Summe über alle Arrayelemente.
      * @param array Array, das aufaddiert wird.
      * @returns Summe aller Arrayelemente.
      */
@@ -144,10 +144,10 @@ public class ArrayExperimente
 
 
     /**
-     * Ermittelt den Wert des groessten im Array enthaltenen Elements.
+     * Ermittelt den Wert des größten im Array enthaltenen Elements.
      * @param array Array, in dem gesucht wird. Es darf 
      * nicht leer sein.
-     * @returns Den groessten vorkommenden Wert.
+     * @returns Den größten vorkommenden Wert.
      */
     public static int maxWert(int[] array)
     {
@@ -160,9 +160,9 @@ public class ArrayExperimente
     
     
     /**
-     * Ermittelt den Index des groessten im Array enthaltenen Elements.
+     * Ermittelt den Index des größten im Array enthaltenen Elements.
      * @param array Array, in dem gesucht wird.
-     * @returns Den Index des groessten vorkommenden Werts.
+     * @returns Den Index des größten vorkommenden Werts.
      */
     public static int maxIndex(int[] array)
     {
@@ -176,11 +176,11 @@ public class ArrayExperimente
     
     
     /**
-     * Ermittelt den Index des groessten im Array enthaltenen Elements. 
+     * Ermittelt den Index des größten im Array enthaltenen Elements. 
      * @param array Array, in dem gesucht wird.
-     * @returns Den Index des groessten vorkommenden Werts.
+     * @returns Den Index des größten vorkommenden Werts.
      */
-    public static int maxIndexKuerzer(int[] aray)
+    public static int maxIndexKuerzer(int[] array)
     {
         // TODO: Formuliere diese Funktion als Einzeiler, indem du
         // Funktionen, die du oben schon geschrieben hast, geschickt aufrufst.
@@ -195,13 +195,13 @@ public class ArrayExperimente
     /**
      * Erstellt ein neues Array, in dem die Elemente des
      * urspruenglichen Array in der umgekehrten Reihenfolge drin sind.
-     * @param array urspruengliches Array, darf nicht null sein
+     * @param array ursprüngliches Array, darf nicht null sein
      * @returns neues Array mit umgekehrter Reihenfolge.
      */
     public static int[] arrayUmdrehen(int[] array)
     {
-        // fuer diese Funktion darf man ein neues Array anlegen, das 
+        // für diese Funktion darf man ein neues Array anlegen, das 
-        // die Eintraege von wendeArray in umgedrehter Reihenfolge enthaelt.
+        // die Einträge von wendeArray in umgedrehter Reihenfolge enthält.
         
         // TODO...
         
@@ -219,8 +219,8 @@ public class ArrayExperimente
      */
     public static void arrayUmdrehenInPlace(int[] array)
     {
-        // Diese Funktion loest die gleiche Aufgabe wie die obere, darf
+        // Diese Funktion löst die gleiche Aufgabe wie die obere, darf
-        // dafuer aber KEIN zusaetzliches Array benutzen, sondern muss 
+        // dafür aber KEIN zusätzliches Array benutzen, sondern muss 
         // (bis auf einzelne int-Variable) im wendeArray arbeiten.
         // TODO...
     }

Stringuebungen.java

@@ -1,7 +1,7 @@
 import java.util.Scanner;
 
 /**
- * Diese Klasse enthaelt Uebungsaufgaben fuer den Umgang mit Strings. 
+ * Diese Klasse enthält Übungsaufgaben für den Umgang mit Strings. 
  * 
  */
 public class Stringuebungen {
@@ -15,7 +15,7 @@ public class Stringuebungen {
         // So kann man eine String-Instanz anlegen: 
         String s1 = new String("Hallo!");
 
-        // Die folgende Kurzschreibweise ist aber allgemein ueblich: 
+        // Die folgende Kurzschreibweise ist aber allgemein üblich: 
         String s2 = "Guten Morgen!";
 
 
@@ -28,8 +28,8 @@ public class Stringuebungen {
         System.out.println("s2 ist " + s2);
 
 
-        //  String-Instanzen koennen nach der Instanziierung nie wieder 
+        // String-Instanzen können nach der Instanziierung nicht mehr  
-        // veraendert werden (man sagt englisch "Strings sind immutable")
+        // verändert werden (man sagt englisch "Strings sind immutable")
         // -- die Referenzen allerdings schon:
         s1 = s2;  // s1 zeigt jetzt auf eine andere String-Instanz
 
@@ -42,12 +42,12 @@ public class Stringuebungen {
         // ein String stehen, notfalls ein leerer:
         System.out.println("" + x + " ist der Wert von x.");
 
-        // Von der Tastatur einzulesen ist leider recht hakelig: Ganz
+        // Um von Tastatur einzulesenmuss ganz
-        // oben in der Datei muss "import java.util.Scanner;" stehen (s.o.),
+        // oben in der Datei "import java.util.Scanner;" stehen (s.o.),
         // dann braucht man (einmal) eine Scanner-Instanz...:
         Scanner tastaturleser = new Scanner(System.in);
         // und dann erst kann man mit dem Scanner etwas von der Tastatur lesen:
-        System.out.println("Bitte gib' einen kurzen Text ein: ");
+        System.out.println("Bitte gib einen kurzen Text ein: ");
         String s3;
         s3 = tastaturleser.nextLine();
 
@@ -64,20 +64,20 @@ public class Stringuebungen {
     public static void stringMethodenDemo() {
         ///////////////////////////////////////////////////
         ///////////// Die Methode length() ////////////////
-        // ermittelt die Laenge eines Strings:
+        // ermittelt die Länge eines Strings:
         String s = "Informatik";
         System.out.println(s + " besteht aus " + s.length() + " Zeichen.");
-        System.out.println("Baden-Wuerttemberg".length());
+        System.out.println("Baden-Württemberg".length());
         System.out.println();
 
         ///////////////////////////////////////////////////
         ///////////// Die Methode indexOf() ////////////////
         // ermittelt den Index der ersten Fundstelle, an 
-        // der ein String innerhalb eines laengeren Strings vorkommt. 
+        // der ein String innerhalb eines längeren Strings vorkommt. 
         // Achtung: die Indizes beginnen bei 0, nicht bei 1 (wie bei Arrays)
         String text = "Barbara mag aber Rhabarber statt Gelaber!";
 
-        // Erst ueberlegen, dann testen: Welche Fundstelle wird ausgegeben?
+        // Erst überlegen, dann testen: Welche Fundstelle wird ausgegeben?
         String gesucht = "bar";
         int index = text.indexOf(gesucht);
         System.out.println("In " + text + " steht " + gesucht 
@@ -118,7 +118,7 @@ public class Stringuebungen {
         ///////////////////////////////////////////////////
         ///////// Die Methoden toUpperCase() und toLowerCase 
         // erzeugen einen neuen String, der nur Gross- (bzw. Klein-)
-        // buchstaben enthaelt:
+        // buchstaben enthält:
         System.out.println("Aus " + text + " wird " + text.toLowerCase());
         System.out.println("Aus " + text + " wird " + text.toUpperCase());  
         System.out.println();
@@ -127,21 +127,21 @@ public class Stringuebungen {
         ///////// Die Methoden subString() schneidet aus einem 
         // String einen Teil heraus. Die Angabe von Startindex und
         // dem (nicht mehr enthaltenen!) Endindex ist allerdings 
-        // gewoehnungsbeduerftig:
+        // gewöhnungsbedürftig:
-        System.out.print(text + "\nenthaelt ab Index 4 bis 7: ");
+        System.out.print(text + "\nenthält ab Index 4 bis 7: ");
         System.out.println(text.substring(4, 7));
     }
 
     /**
-     * Zaehlt die Vorkommen eines Buchstabens innerhalb eines Textes.
+     * Zählt die Vorkommen eines Buchstabens innerhalb eines Textes.
-     * @param text zu durchsuchender Text
+     * @param text der zu durchsuchender Text
-     * @param z Buchstabe, nach dem gesucht wird
+     * @param z der Buchstabe, nach dem gesucht wird
-     * @return Zahl der Vorkommen von z in text
+     * @return Zahl Anzahl, wie oft z in text vorkommt
      */
     public static int anzahlVorkommen(String text, char z) {
-        /*# Geht mit einer Schleife den gesamten String durch;
+        /*# Geh mit einer Schleife den gesamten String durch;
-         * erhöhe den Zaehler jedesmal, wenn  das Zeichen
+         * erhöhe den Zähler jedesmal, wenn  das Zeichen
-         * im String vorkommt; gebe dann den Wert des Zaehlers zurueck. */ 
+         * im String vorkommt; gebe dann den Wert des Zählers zurück. */ 
 
         int anzahl = 0;
 
@@ -151,18 +151,18 @@ public class Stringuebungen {
 
 
     /**
-     * Dreht den uebergebenen String herum.
+     * Dreht den übergebenen String herum.
      * Aus GEWINNER wird also RENNIWEG.
      * 
      * @param text umzudrehender String
      * @return den umgedrehten String
      */
     public static String rueckwaerts(String text) {
-        /*#Dies kann auf verschiedene Arten gelößt werden.
+        /*#Dies kann auf verschiedene Arten gelöst werden.
          * Eine Möglichkeit ist, du gehst mit einer Schleife 
-         * rueckwaerts durch den String 
+         * rückwärts durch den String 
          * das geht z.B. mit for(int i=s.length()-1; i>=0; i--) und
-         * haenge sie seine Buchstaben an den ergebnis-String an.
+         * hänge die Buchstaben an den ergebnis-String an.
          */
 
         String ergebnis = "";
@@ -173,8 +173,8 @@ public class Stringuebungen {
 
     /**
      * Ermittelt, ob ein Text ein Palindrom ist.
-     * Ein Text ist ein Palindrom, wenn er rueckwaerts wie vorwaerts
+     * Ein Text ist ein Palindrom, wenn er rückwärts wie vorwärts
-     * gelesen das gleiche ergibt. Beispiele sind ANNA, OTTO, RENTNER, RELIEFPFEILER 
+     * gelesen das Gleiche ergibt. Beispiele sind ANNA, OTTO, RENTNER, RELIEFPFEILER 
      * oder auch als Palindromsatz ERIKAFEUERTNURUNTREUEFAKIRE.
      * 
      * Das Wort Bob gilt wegen der Gross-/Kleinschreibung
@@ -184,10 +184,10 @@ public class Stringuebungen {
      * @return true, wenn der Text ein Palindrom ist; false sonst.
      */
     public static boolean istPalindrom(String text ) {
-        /*# Diese Aufgabe kann auf verschiedene Arten geloest werden. 
+        /*# Diese Aufgabe kann auf verschiedene Arten gelöst werden. 
          * Eine nutzt auf elegante Weise anderen Code. Eine andere geht so: 
          * Durchlaufe den Text in einer Schleife und vergleiche den
-         * ersten mit dem letzten Buchstaben (im naechsten Durchlauf dann den
+         * ersten mit dem letzten Buchstaben (im nächsten Durchlauf dann den
          * zweiten mit dem vorletzten usw.). 
          */
 
@@ -199,31 +199,31 @@ public class Stringuebungen {
     
     
     /**
-     * Prueft, ob zwei Woerter Anagramme voneinander sind.
+     * Prüft, ob zwei Wörter Anagramme voneinander sind.
      * 
-     * Anagramme nennt man Woerter (oder Texte), die durch 
+     * Anagramme nennt man Wörter (oder Texte), die durch 
      * Umordnung ihrer Buchstaben auseinander hervorgehen. 
      * Folgende Wort- bzw. Textpaare sind beispielsweise 
-     * Anagramme voneinander:<p>
+     * Anagramme voneinander:
-     * Leo / Oel<p>
+     * Leo / Oel
-     * shit / hits / this<p>
+     * shit / hits / this
-     * SAU / USA<p>
+     * SAU / USA
-     * ABITURE / BAU TIER<p>
+     * ABITURE / BAU TIER
-     * STAUFENS /  FAN-TUSSE<p>
+     * STAUFENS /  FAN-TUSSE
-     * Frodos Ehe / Sehr doofe<p>
+     * Frodos Ehe / Sehr doofe
      * 
-     * Zwei Saetze gelten auch dann als Anagramme, wenn dafür 
+     * Zwei Sätze gelten auch dann als Anagramme, wenn dafür 
      * Leer- und Satzzeichen sowie Kleinschreibung ignoriert 
-     * werden muessen wie bei "rauschen" / "Hase nur C".
+     * werden müssen wie bei "rauschen" / "Hase nur C".
      * 
      * @param wort1 Der erste Text.
      * @param wort2 Der zweite Text.
      * @return ob die beiden Texte Anagramme voneinander sind.
      */
     public static boolean sindAnagramme(String wort1, String wort2 ) {
-        /*# Mache dir klar, dass es nur auf die Haeufigkeit der 
+        /*# Mache dir klar, dass es nur auf die Häufigkeit der 
          * Buchstaben ankommt. Und dann mach dir keine 
-         * unnoetige Arbeit, sondern benutze fertigen Code. 
+         * unnötige Arbeit, sondern benutze fertigen Code. 
          */
 
         boolean ergebnis = true;
@@ -234,32 +234,32 @@ public class Stringuebungen {
     
 
     /**
-     * Für Experten: Die Caesar-Chiffre
+     * Für Experten: Die Cäsar-Chiffre
-     * Die Funktion chiffriert einen Klartext mit der Caesar-Chiffre und
+     * Die Funktion chiffriert einen Klartext mit der Cäsar-Chiffre und
-     * dem angegebenen Schluessel. 
+     * dem angegebenen Schlüssel. 
-     * Der Klartext wird  um "schluessel" Stellen im Alphabet 
+     * Der Klartext wird  um "Schlüssel" Stellen im Alphabet 
-     * weitergeschoben. Mit dem Schluessel 3 wird also 
+     * weitergeschoben. Mit dem Schlüssel 3 wird also 
      * 
      * aus "ABC" der Geheimtext DEF 
      * aus "VWXYZ" der Geheimtext YZABC   
      * aus "INFO" der Geheimtext LQIR
      * 
-     * Der Einfachheithalber dürft ihr annehmen, dass der zu verschlüsselnde
+     * Der Einfachheit halber dürft ihr annehmen, dass der zu verschlüsselnde
      * Text "normalisiert" ist, d.h. nur Großbuchstaben enthält.
      * 
-     * @param klartext zu verschluesselnder Klartext
+     * @param klartext zu verschlüsselnder Klartext
      * @param schluessel Verschiebung im Alphabet (nach rechts)
-     * @return den verschluesselten Text (Geheimtext).
+     * @return den verschlüsselten Text (Geheimtext).
      */
     public static String caesarChiffrieren(String klartext, int schluessel) {
-        /*# Es gibt verschiedene Moeglichkeiten, die Verschiebung 
+        /*# Es gibt verschiedene Möglichkeiten, die Verschiebung 
          * umzusetzen; eine besteht darin, alle Buchstaben einzeln in 
          * int-Werte umzurechnen. Man kann char-Werte mit einer Zuweisung wie
          * int zahl = (int) charVariable;
          * ganz einfach in int-Werte umwandeln. Dann rechnet man die eigentliche 
-         * Caesar-Verschiebung aus und wandelt mit
+         * Cäsar-Verschiebung aus und wandelt mit
          * char c = (char) intVariable;
-         * zurueck in Buchstaben. 
+         * zurück in Buchstaben. 
          * 
          * Aber Achtung: 'A' hat nicht den Zahlenwert 0! 
          * Finde zuerst raus, welchen Zahlenwert A hat.