Listen, Arrays und Strings in Java

Eine ArrayList speichert Werte in einer Reihenfolge. Sie wächst, wenn du ein Element hinzufügst, und schrumpft, wenn du eines entfernst. Jedes Element hat einen Index, beginnend bei 0. Importiere die Klasse, bevor du sie verwendest: import java.util.ArrayList;.

Erstelle eine typisierte Liste

ArrayList<String> drinks = new ArrayList<>();
drinks.add("tea");
drinks.add("milk");

Der Typ in <String> gibt an, was die Liste speichert. Durch die Diamant-Syntax <> rechts kann Java denselben Typ ableiten. Die Liste beginnt leer mit der Größe 0; nach diesen beiden Aufrufen enthält sie [tea, milk] und hat die Größe 2. Wenn du die Liste direkt ausgibst, zeigt sie ihre Elemente: System.out.println(drinks);.

Der Elementtyp einer Liste muss ein Klassentyp sein. Verwende für Zahlen eine Wrapperklasse: Integer für int, Double für double, Boolean für boolean oder Character für char. ArrayList<int> lässt sich nicht kompilieren. Bei ArrayList<Integer> numbers = new ArrayList<>(); funktioniert numbers.add(5), weil Java den int automatisch in einen Integer umwandelt. Beim Einlesen in int n = numbers.get(0); wird der Wert wieder ausgepackt.

Verfolge jede Indexänderung

String old = drinks.set(0, "coffee");
drinks.add(1, "water");
String last = drinks.get(2);

set(0, "coffee") ersetzt das erste Element und gibt den alten Wert zurück, daher ist old gleich "tea". Die Größe bleibt 2. Das Einfügen von "water" an Index 1 verschiebt "milk" nach rechts. Die Liste ist nun [coffee, water, milk]; last ist "milk" und die Größe ist 3.

Der zusätzlich erlaubte Einfügeindex ist die Position direkt nach dem aktuellen letzten Element. Bei dieser Liste hängt add(3, "juice") einen Wert an, aber get(3) würde vor diesem Einfügen fehlschlagen. Ein ungültiger Index löst eine IndexOutOfBoundsException aus. Verwende get(size() - 1) für das letzte Element, nachdem du geprüft hast, dass die Liste nicht leer ist.

Beginne mit Daten oder sammle Eingaben

Mit import java.util.List; erstellt new ArrayList<>(List.of("red", "green", "blue")) eine veränderbare Liste mit diesen Werten. List.of(...) allein erstellt eine nicht modifizierbare Liste: add, set und remove lösen eine UnsupportedOperationException aus. Du wirst auch List<String> names = new ArrayList<>(); sehen; die Variable mit dem allgemeinen Typ List unterstützt diese Listenmethoden ebenfalls.

Um Zeilen bis zu einer leeren Zeile zu sammeln, verwende einen Scanner namens scanner und eine leere Liste namens lines:

while (true) {
    String line = scanner.nextLine();
    if (line.isEmpty()) {
        break;
    }
    lines.add(line);
}

Die Zeile zum Beenden wird vor dem Hinzufügen geprüft und daher nicht gespeichert. lines.size() zählt die gespeicherten Zeilen. lines.isEmpty() prüft, ob keine vorhanden sind, und lines.clear() entfernt sie alle, wenn du die Liste erneut verwenden möchtest.

Das Entfernen eines Elements ändert sowohl die Größe als auch die Indizes der späteren Elemente. Eine Suche zeigt, ob ein Wert vorhanden ist oder wo er jetzt steht. Halte den Unterschied zwischen einem Wert und seiner Position klar, besonders in einer Liste von Ganzzahlen.

Zwei Bedeutungen von remove

Für [coffee, water, milk] gibt remove(0) den Wert "coffee" zurück und hinterlässt [water, milk]. Der alte Index 2 für "milk" ist nun ungültig; dieser Wert ist an Index 1 gerückt. Ein gespeicherter Index ist nur nützlich, solange Änderungen die damit beschriebenen Positionen nicht verschoben haben.

Entfernen nach Wert bedeutet nicht, dass jeder Treffer entfernt wird. Ausgehend von [a, b, a] hinterlässt remove("a") die Liste [b, a]. Ein zweiter Aufruf entfernt das verbliebene "a". Das Entfernen eines fehlenden Werts gibt false zurück und lässt die Liste unverändert, sodass du das Ergebnis direkt verwenden kannst:

boolean removed = names.remove("Lena");
if (removed) {
    System.out.println("Name removed");
}

Die Überladungsfalle bei Ganzzahlen

Ein int-Argument wählt die Indexform, selbst wenn die Liste Ganzzahlen speichert:

ArrayList<Integer> numbers = new ArrayList<>(List.of(10, 20, 30));
int removed = numbers.remove(1);
boolean found = numbers.remove(Integer.valueOf(10));

Der erste Aufruf entfernt das Element an Index 1, daher ist removed gleich 20 und die Liste wird zu [10, 30]. Der zweite Aufruf übergibt ausdrücklich ein Integer-Objekt. Er entfernt den Wert 10, setzt found auf true und hinterlässt [30]. Ein Aufruf von remove(10) auf der ursprünglichen Liste mit drei Elementen würde Index 10 verwenden und eine IndexOutOfBoundsException auslösen.

Wähle ein Suchergebnis

Für colors = [red, green, blue, green] ist contains("green") gleich true, indexOf("green") gleich 1 und lastIndexOf("green") gleich 3. contains liefert eine Ja-Nein-Antwort. Die beiden Indexmethoden liefern die erste oder letzte Position eines Treffers. Ein fehlender Wert ergibt entsprechend false oder -1.

Diese Methoden vergleichen Elemente mit equals. String-Inhalte müssen einschließlich der Groß- und Kleinschreibung genau übereinstimmen: indexOf("Green") ist für diese Liste -1. Für eine Suche ohne Beachtung der Groß- und Kleinschreibung kann eine Schleife jeden Namen mit equalsIgnoreCase vergleichen.

Ein Treffer an Index 0 ist ebenfalls ein Treffer. Die Prüfung indexOf(x) > 0 übersieht ihn. Wenn du die Position brauchst, prüfe ausdrücklich auf die Kennzeichnung für einen fehlenden Wert:

int index = colors.indexOf("red");
if (index != -1) {
    colors.remove(index);
}

Hier gibt die Suche 0 zurück, die Prüfung ist erfolgreich, und das Entfernen an Index 0 hinterlässt [green, blue, green]. Um doppelte Namen zu vermeiden, prüfe vor dem Hinzufügen: if (!names.contains(name)) { names.add(name); }. Um alle Vorkommen zu entfernen, kannst du das Entfernen wiederholen, solange contains true ergibt, oder eine sichere rückwärts gerichtete Schleife verwenden. Eine vorwärts gerichtete Schleife, die nach dem Entfernen immer weiterzählt, kann ein verschobenes Element überspringen.

Eine Listenvariable enthält eine Referenz auf ein Objekt. Sie enthält nicht alle Elemente in der Variable selbst. Das erklärt, warum das Ändern einer Liste über einen Namen einen anderen Namen betreffen kann und warum die Zuweisung an einen Parameter eine andere Wirkung hat als das Bearbeiten seiner Elemente.

Verfolge die Referenzen

ArrayList<String> original = new ArrayList<>(List.of("tea"));
ArrayList<String> alias = original;
ArrayList<String> copy = new ArrayList<>(original);
alias.add("milk");
copy.add("juice");

original und alias zeigen auf eine Liste. Nach dem Hinzufügen über alias zeigen beide [tea, milk]. Die Kopie ist eine separate Liste, die vor diesem Hinzufügen erstellt wurde, und enthält daher [tea, juice]. Zwei Namen für ein Objekt heißen Aliasse. Eine Zuweisung kopiert eine Referenz; der Kopierkonstruktor erstellt eine neue Liste und kopiert die Elemente hinein.

Die kopierte Liste enthält Referenzen auf dieselben Elementobjekte. Bei Strings und Wrapperwerten können diese Elementobjekte nicht verändert werden, sodass das Ersetzen eines Listenplatzes nicht den Platz in der anderen Liste ändert. Das Kopieren einer Liste reicht aus, damit diese beiden Listen unabhängig voneinander Elemente hinzufügen, entfernen und ersetzen können.

Eine Methode erhält eine Kopie der Referenz

Java übergibt Argumente als Wert. Bei einer Liste ist dieser Wert eine Referenz. Der Aufrufer und der Parameter zeigen zunächst auf dieselbe Liste:

static void addBonus(ArrayList<Integer> scores, int bonus) {
    for (int i = 0; i < scores.size(); i++) {
        scores.set(i, scores.get(i) + bonus);
    }
}

Der Aufruf addBonus(scores, 5) auf [70, 85] ändert die Liste des Aufrufers zu [75, 90]. Die Methode muss keine Liste zurückgeben, weil sie das gemeinsam genutzte Objekt bearbeitet. Die Zuweisung scores = new ArrayList<>(); innerhalb der Methode lässt dagegen nur ihren lokalen Parameter auf die neue Liste verweisen. Die Variable des Aufrufers zeigt weiterhin auf die alte Liste.

Ein int-Parameter erhält eine kopierte Zahl. Das Ändern dieses Parameters kann die int-Variable des Aufrufers nicht ändern. In beiden Fällen ist der Parameter lokal; der Unterschied besteht darin, ob sein Wert zu einem gemeinsam genutzten veränderlichen Objekt führt.

Gib neue Daten zurück, wenn die Aufgabe es verlangt

static ArrayList<String> longWords(ArrayList<String> words, int minLength) {
    ArrayList<String> result = new ArrayList<>();
    for (String word : words) {
        if (word.length() >= minLength) {
            result.add(word);
        }
    }
    return result;
}

Die Methode liest words und schreibt nur in result, sodass die Eingabe unverändert bleibt. Eine Methode, die ein Argument ändert, sollte dieses Verhalten vermitteln, wie es addBonus tut. Bei einer Methode, die neue Daten zurückgibt, lässt sich die Ausgabe leichter getrennt von der Eingabe prüfen.

Vergleiche Inhalte und behandle fehlende Ergebnisse

a == b prüft, ob zwei Listenreferenzen auf dasselbe Objekt zeigen. a.equals(b) prüft, ob die Listen gleich groß sind und gleiche Elemente in derselben Reihenfolge enthalten. Zwei getrennt erstellte Listen [1, 2] haben gleiche Inhalte, aber unterschiedliche Identitäten; [2, 1] hat in der Listenreihenfolge keinen gleichen Inhalt.

Eine leere Liste ist ein tatsächliches Objekt mit der Größe 0. Eine Schleife darüber wird nullmal ausgeführt, aber get(0) schlägt fehl, weil es keine Elementindizes gibt. null bedeutet, dass kein Listenobjekt vorhanden ist; selbst size() löst dann eine NullPointerException aus. Eine Methode ohne Treffer kann eine leere Ergebnisliste zurückgeben, sodass der Aufrufer das Ergebnis normal durchlaufen kann.

Ein Array speichert eine feste Anzahl von Elementen eines Typs. Du wählst seine Länge beim Erstellen. Elemente können sich ändern, aber die Anzahl der Speicherplätze in diesem Array bleibt gleich. Arrays können primitive Werte direkt speichern.

Erstelle und fülle Speicherplätze

int[] scores = new int[5];
scores[0] = 90;
int first = scores[0];
int[] primes = {2, 3, 5, 7, 11};

new int[5] erstellt fünf Speicherplätze. Ihre Indizes sind 0, 1, 2, 3 und 4. Mit eckigen Klammern liest und schreibst du einen Speicherplatz, sodass first den Wert 90 erhält. Der Initialisierer für primes erstellt und füllt fünf Speicherplätze. Wenn ein gefülltes Array als Ausdruck benötigt wird, etwa als Methodenargument, verwende new int[] {2, 3, 5}.

Die Länge ist ein Feld: scores.length, ohne Klammern. Es zählt alle Speicherplätze, auch diejenigen, denen du selbst noch keinen Wert zugewiesen hast. Das Hinzufügen eines Werts an Speicherplatz 0 ändert die Länge nicht von 5 auf 1.

Diese Namen sind nicht austauschbar. Ein Array hat keine Methode size(), und bei einem String braucht length Klammern.

Kenne die Startwerte

Neue Array-Speicherplätze erhalten Standardwerte. Arrays primitiver Zahlentypen beginnen mit null: 0 für int, 0,0 für double. Ein boolean[] beginnt mit false; ein char[] beginnt mit dem Zeichen, dessen Code null ist, geschrieben als '\u0000'. Arrays von Klassentypen, einschließlich String[], beginnen mit null-Referenzen.

String[] words = new String[3];
words[0] = "sun";
System.out.println(words[0].length());

Dies gibt 3 aus, weil Speicherplatz 0 nun auf "sun" verweist. Die Speicherplätze 1 und 2 enthalten weiterhin null. Der Aufruf von words[1].length() löst eine NullPointerException aus: Dort steht noch kein String. Ein standardmäßig mit null belegter Speicherplatz unterscheidet sich von einem leeren String "", der ein Objekt mit der Länge 0 ist.

Lies Ausgaben und bleibe innerhalb des Arrays

Importiere java.util.Arrays und verwende System.out.println(Arrays.toString(scores));, um [90, 0, 0, 0, 0] auszugeben. Die direkte Ausgabe von scores zeigt einen Typ- und Identitätscode wie [I@1b6d3586, nicht die Elemente. Der Identitätscode ist keine brauchbare Darstellung der gespeicherten Zahlen.

Für eine Woche mit Temperaturen in Grad Celsius:

double[] temps = {12.5, 14.0, 9.5, 11.0, 15.5, 13.0, 10.5};
temps[2] = 10.0;

Der Messwert des dritten Tages ändert sich von 9,5 auf 10,0. Der erste Messwert ist temps[0]; der letzte ist temps[6] oder temps[temps.length - 1]. temps[7] liegt außerhalb des Arrays. Java löst bei einem ungültigen Array-Index eine ArrayIndexOutOfBoundsException aus. Verwende in einer indexbasierten Schleife i < temps.length: i <= temps.length versucht, einen zusätzlichen Speicherplatz nach dem letzten gültigen zu lesen. Ein Array der Länge null hat überhaupt keine gültigen Elementindizes.

Eine Array-Variable enthält genau wie eine Listenvariable eine Referenz. Die Zuweisung dieser Referenz erzeugt einen weiteren Namen für dasselbe Array. Eine separate Kopie benötigt ein neues Array-Objekt, und für den Inhaltsvergleich brauchst du eine Methode, die die Speicherplätze prüft.

Zuweisen und Kopieren

int[] a = {4, 9, 2};
int[] alias = a;
int[] copy = Arrays.copyOf(a, a.length);
alias[0] = 99;

Nun zeigen a und alias beide [99, 9, 2]; copy zeigt weiterhin [4, 9, 2]. Arrays.copyOf(a, a.length) erstellt ein neues Array derselben Länge. Auch a.clone() kann es kopieren. Importiere java.util.Arrays für die Hilfsmethoden.

Eine andere angeforderte Länge ändert das neue Array, nicht das alte. Arrays.copyOf(new int[] {2, 3, 5}, 4) ergibt [2, 3, 5, 0]. Zusätzliche Speicherplätze erhalten Standardwerte. Damit eine Variable auf ein größeres Array verweist, weise ihr die zurückgegebene Kopie zu. Jeder Alias des Originals verweist weiterhin auf das alte Array.

Methodenaufrufe nutzen das Objekt gemeinsam

static void doubleAll(int[] values) {
    for (int i = 0; i < values.length; i++) {
        values[i] = values[i] * 2;
    }
}

Der Parameter erhält eine Kopie der Referenz. Daher ändert die Methode die Array-Speicherplätze des Aufrufers. Eine Neuzuweisung von values zu einem neuen Array würde nur den Parameter ändern. Eine Methode kann stattdessen ein neues Array zurückgeben: return new int[] {values[0], values[values.length - 1]}; erzeugt für die Eingabe {4, 9, 2} den Wert [4, 2]. Dieser Ausdruck benötigt eine nicht leere Eingabe, weil er zwei Indizes liest.

Inhaltliche Gleichheit ist bei Arrays anders

Für getrennt erstellte Arrays a = {1, 2} und b = {1, 2} sind sowohl a == b als auch a.equals(b) false: equals prüft bei Arrays die Identität. Arrays.equals(a, b) ist true, weil die entsprechenden Elemente übereinstimmen. Das unterscheidet sich von ArrayList, deren equals den Inhalt in seiner Reihenfolge vergleicht.

Speichere einen Wert vor dem Überschreiben

Um zwei Positionen zu vertauschen, halte einen alten Wert in einer temporären Variable fest:

int temp = a[0];
a[0] = a[2];
a[2] = temp;

Ausgehend von {4, 9, 2} speichert die erste Zeile den Wert 4. Die zweite ergibt [2, 9, 2]. Die dritte stellt die gespeicherte 4 an Index 2 wieder her und vervollständigt [2, 9, 4]. Ohne temp würde die Zuweisung a[2] = a[0] nach der zweiten Zeile erneut 2 kopieren und die ursprüngliche 4 ginge verloren.

Wähle eine Struktur, die zu den Daten passt

Arrays kommen auch in main(String[] args) und als Ergebnis von String.split vor. Für ein String[] words erstellt new ArrayList<>(Arrays.asList(words)) eine Liste, die wachsen kann. Erstelle für ein int[] eine ArrayList<Integer> und füge jede Ganzzahl in einer Schleife hinzu. Arrays.asList behandelt bei dem primitiven Array das gesamte Array als ein Element und erstellt daher keine Liste seiner einzelnen Zahlen.

Mit einer Schleife kann ein Stück Code jedes Element verarbeiten. Die Wahl hängt davon ab, was der Schleifenrumpf braucht: nur einen Wert, seine Position oder eine Möglichkeit, in die Collection zurückzuschreiben. Sowohl Arrays als auch ArrayLists unterstützen indexbasierte Schleifen und for-each-Schleifen.

Durchlaufe Werte der Reihe nach

for (String task : tasks) {
    System.out.println(task);
}

Lies dies als „für jede Aufgabe in tasks“. Bei [shop, cook, clean] gibt die Schleife die drei Strings in dieser Reihenfolge aus. Die Schleifenvariable hat den Elementtyp. Verwende bei ArrayList<Integer> den Typ int, um für jeden Wert Unboxing auszuführen, oder Integer, um die Wrapperreferenz zu behalten. Bei String-Zeichen durchläuft for (char c : word.toCharArray()) die char-Werte.

Eine for-each-Schleife stellt keinen Index bereit. Wenn du nummerierte Zeilen brauchst, verwende eine indexbasierte Schleife:

for (int i = 0; i < tasks.size(); i++) {
    System.out.println((i + 1) + ". " + tasks.get(i));
}

Der Index beginnt bei 0, aber die angezeigte Zeilennummer beginnt bei 1. Die Klammern sorgen dafür, dass i + 1 addiert wird, bevor das Ergebnis Teil des Texts wird. Ändere bei einem Array die Bedingung zu i < tasks.length und lies tasks[i]. Eine while-Schleife kann dieselbe Aufgabe erledigen, indem sie vor der Schleife einen Zähler initialisiert und ihn im Rumpf erhöht.

Schreibe über eine Position zurück

int[] nums = {4, 9, 2};
for (int n : nums) {
    n = n * 2;
}

Dies lässt das Array unverändert. Jeder Durchlauf legt eine Kopie eines primitiven Werts in n ab; eine Zuweisung an diese lokale Variable schreibt nicht in den ursprünglichen Speicherplatz. Um das Array zu ändern:

for (int i = 0; i < nums.length; i++) {
    nums[i] = nums[i] * 2;
}

Das Ergebnis ist [8, 18, 4]. Für eine Ganzzahlliste lautet die entsprechende Aktualisierung list.set(i, list.get(i) * 2). Der Index sagt Java, welches gespeicherte Element ersetzt werden soll.

Passe die Schleifengrenzen an den Rumpf an

Für die rückwärts gerichtete Traversierung einer Liste beginne bei tasks.size() - 1, fahre fort, solange i >= 0 gilt, und verwende i--. So werden clean, cook und dann shop durchlaufen. Um jedes zweite Element auszuwählen, kannst du in einer vorwärts gerichteten Schleife i += 2 verwenden.

Nachbarvergleiche benötigen einen kürzeren Bereich. Wenn der Rumpf sowohl list.get(i) als auch list.get(i + 1) liest, lautet die Bedingung i < list.size() - 1. Die letzte gültige Startposition ist das vorletzte Element. Mit der üblichen Bedingung für das vollständige Durchlaufen würde die Schleife versuchen, nach dem letzten Element einen nicht vorhandenen Nachbarn zu lesen.

Wenn du zwei gleich lange Listen gemeinsam verarbeitest, greife mit einem Index auf beide zu. Zum Beispiel bezeichnen names.get(i) und scores.get(i) die einander entsprechenden Einträge. Eine for-each-Schleife ist einfacher, wenn die Position keine Rolle spielt, etwa beim Ausgeben jedes Namens oder beim Addieren jedes Werts zu einer Summe.

Ein Start bei 1 überspringt unbemerkt das erste Element. Mit <= size() oder <= length wird ein zusätzlicher ungültiger Index verwendet. Eine leere Liste oder ein leeres Array braucht keine besondere Regel für das Durchlaufen: Die Anfangsbedingung ist false, sodass der Rumpf nullmal ausgeführt wird. Jeder anschließende Code, der durch die Anzahl dividiert oder ein Element liest, muss den leeren Fall selbst behandeln.

Ein Akkumulator hält ein Ergebnis fest, das über mehrere Schleifendurchläufe aufgebaut wird. Initialisiere ihn vor der Schleife, aktualisiere ihn darin und verwende ihn danach. Der Startwert hängt von der Aufgabe ab: Eine Summe oder ein Zähler beginnt bei 0, während ein Maximum ein tatsächliches Element als Startwert braucht.

Summen und Mittelwerte

int sum = 0;
for (int value : numbers) {
    sum += value;
}
if (!numbers.isEmpty()) {
    double average = (double) sum / numbers.size();
    System.out.println(average);
}

Für [4, 7, 8] ändert sich sum von 0 auf 4, dann auf 11 und dann auf 19. Beide Operanden in sum / numbers.size() wären Ganzzahlen, was 6 ergibt. Die explizite Typumwandlung von sum vor der Division ergibt ungefähr 6,33. Eine Umwandlung des bereits berechneten Quotienten würde lediglich die abgeschnittene 6 in 6,0 umwandeln.

Eine leere Collection hat keinen gewöhnlichen Mittelwert. Eine Ganzzahldivision durch null löst eine ArithmeticException aus; die Gleitkommadivision 0.0 / 0 ergibt NaN. Entscheide vor der Division, was der leere Fall für das Programm bedeutet, etwa die Anzeige „Keine Messwerte“. Für die Dezimalstrecken [5.0, 7.5, 10.0] km beträgt die double-Summe 22,5 km und der Mittelwert 7,5 km.

Zähle nur Treffer

Ein bedingter Zähler beginnt bei 0 und wird nur erhöht, wenn seine Prüfung erfolgreich ist. Für die Temperaturen {22, 27, 31, 24, 26} Grad Celsius ergibt if (t > 25) { count++; } den Wert 3. Setze die Initialisierung außerhalb der Schleife; das Zurücksetzen von count bei jedem Durchlauf würde vorherige Treffer verwerfen.

Finde einen Extremwert und seine Position

Beginne bei einem nicht leeren Array mit int max = values[0];. Ersetze max, wann immer ein besuchter Wert größer ist. Ein Start bei 0 schlägt bei {-5, -2, -9} fehl: Er meldet 0, obwohl kein Element diesen Wert hat. Der Start mit -5 ermöglicht es der Schleife, das korrekte Maximum -2 zu finden. Ein Minimum verwendet dasselbe Muster mit <.

Wenn die Position wichtig ist, merke dir den Index des besten Werts:

int best = 0;
for (int i = 1; i < numbers.size(); i++) {
    if (numbers.get(i) > numbers.get(best)) {
        best = i;
    }
}

Für [4, 7, 8] endet best bei 2 und numbers.get(best) ist 8. Die Schleife beginnt bei 1, weil Index 0 bereits der anfängliche Kandidat ist. Bei > ersetzt ein gleicher Wert den aktuellen Kandidaten nicht, sodass das erste Maximum erhalten bleibt. Bei >= ersetzt jeder Gleichstand den Kandidaten, sodass das letzte Maximum erhalten bleibt. Prüfe auf eine leere Collection, bevor du einen Kandidaten an Index 0 festlegst.

Sammle passende Werte

Beim Filtern dient eine leere Ergebnisliste als Akkumulator. Durchlaufe jedes Wort, füge es hinzu, wenn word.length() > 4 gilt, und gib das Ergebnis zurück. Für [sun, planet, moon, galaxy] ist das Ergebnis [planet, galaxy]. Das Lesen der Eingabe und Hinzufügen zu einer separaten Liste lässt die Eingabe unverändert.

Bei zwei Integer-Elementen vergleicht == die Objektidentität. Zwischengespeicherte kleine Werte können diesen Fehler verbergen; gleiche größere Werte können verschiedene Objekte sein. Vergleiche mit equals oder führe zuerst Unboxing in int-Variablen aus. Die numerischen Operatoren <, >, <= und >= führen Unboxing für Wrapperwerte aus, sodass der Code für den besten Index ihre Zahlen vergleicht.

Eine lineare Suche prüft Elemente der Reihe nach. Sie funktioniert bei Daten in beliebiger Reihenfolge. Eine erfolgreiche Suche nach dem ersten Treffer kann früh enden; eine erfolglose Suche muss das Ende erreichen, bevor feststeht, dass kein Element übereinstimmt.

Gib den Index des ersten Treffers zurück

static int indexOfName(ArrayList<String> names, String target) {
    for (int i = 0; i < names.size(); i++) {
        if (names.get(i).equals(target)) {
            return i;
        }
    }
    return -1;
}

Steht der erste passende Name an Index 2, prüft die Methode die Indizes 0, 1 und 2 und gibt dann sofort 2 zurück. Das return -1 steht nach der Schleife, weil erst ein vollständiger Durchlauf das Fehlen feststellt. Ein else { return -1; } innerhalb der Schleife würde beim ersten nicht passenden Element abbrechen und alle späteren Kandidaten ignorieren.

Die Kennzeichnung für einen fehlenden Wert -1 kann kein gültiger Index sein. Der Aufrufer muss sie prüfen, bevor er das Ergebnis liest:

int index = indexOfName(names, "Ahmed");
if (index != -1) {
    System.out.println(names.get(index));
}

Die Prüfung index > 0 würde einen gültigen Treffer an Index 0 übersehen. Die direkte Verwendung von -1 in get würde eine Ausnahme auslösen. Bei einer leeren Liste wird der Schleifenrumpf nie ausgeführt und die Methode gibt korrekt -1 zurück.

Passe den Vergleich an die Aufgabe an

Für exakte Listenwerte führen contains und indexOf bereits eine lineare Suche aus. Schreibe eine Schleife für ein Array oder eine Bedingung wie „beginnt mit L“. Verwende equals oder equalsIgnoreCase für Strings, == für primitive Werte und equals für zwei Integer-Objekte. Eine Identitätsprüfung bei Strings kann gleichen Text übersehen.

Prüfe für String[] cities = {"Oslo", "Lima", "Lagos", "Pune"} den Ausdruck cities[i].startsWith("L"). Index 0 erfüllt die Bedingung nicht; Index 1 erfüllt sie, daher ist das Ergebnis der Suche nach dem ersten Treffer 1. Wenn die Aufgabe alle Treffer verlangt, kehre dort nicht zurück. Hänge die Indizes der Treffer an eine Ergebnisliste an und durchlaufe den Rest; das ergibt [1, 2]. Um Treffer zu zählen, erhöhe einen Zähler, statt Positionen zu speichern.

Wähle die Form der Antwort

Eine Ja-Nein-Suche kann mit boolean found = false; beginnen. Setze den Wert bei einem Treffer auf true und verlasse die Schleife mit break. Ohne break bleibt die endgültige Antwort true, aber das Programm prüft Werte, die es nicht mehr braucht. Eine Suchmethode kann auch sofort true und nach der Schleife false zurückgeben.

Wenn ein Element zurückgegeben wird, braucht es ein separates Ergebnis für „nichts gefunden“. Bei einem String ist dies oft null; der Aufrufer muss darauf prüfen, bevor er eine String-Methode aufruft. Die Rückgabe eines Index mit -1 macht den Fall eines fehlenden Werts sichtbar, ohne einen leeren String als fehlende Daten auszugeben.

Zähle den tatsächlichen Aufwand der Suche

Ein gesuchter Wert an der ersten Position benötigt einen Vergleich. Ein gesuchter Wert an der dritten Position benötigt drei. Ein fehlender Wert unter 10.000 Namen benötigt alle 10.000 Vergleiche. Der erste fehlgeschlagene Vergleich kann nicht feststellen, dass der gesuchte Wert an den übrigen Positionen fehlt. Auch eine Suche nach allen Treffern prüft jedes Element, selbst nach einem frühen Treffer, weil spätere Werte ebenfalls passen können.

Das Entfernen aus einer ArrayList ändert die Positionen, die eine Schleife durchlaufen soll. Das sichere Vorgehen hängt davon ab, ob du die ursprüngliche Liste ändern oder ein separates Ergebnis erstellen musst. Das Ersetzen von Werten ist einfacher, weil die Positionen dabei erhalten bleiben.

Sieh, wie eine vorwärts gerichtete Schleife einen Wert überspringt

Angenommen, eine Schleife entfernt gerade Zahlen aus [3, 8, 8, 5] und erhöht immer i. An Index 1 entfernt sie die erste 8. Die zweite 8 rückt an Index 1, aber der nächste Durchlauf verwendet Index 2. Das Ergebnis ist [3, 8, 5], eine gerade Zahl bleibt also stehen. Die Bedingung war richtig; das Vorrücken nach dem Entfernen war falsch.

Auch eine for-each-Schleife über eine ArrayList darf keine Elemente über die Liste hinzufügen oder entfernen. Sie verwendet einen Iterator, dessen Traversierungszustand nach einer Änderung nicht mehr zur Liste passt. Java meldet normalerweise eine ConcurrentModificationException. Manche Änderungen können stattdessen die Schleife unbemerkt beenden, sodass ein Element nicht besucht wird. Das Ausbleiben einer Ausnahme macht diese Änderung nicht sicher.

Entferne rückwärts, damit ungeprüfte Positionen stabil bleiben

for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 0) {
        numbers.remove(i);
    }
}

Bei [3, 8, 8, 5] enthält Index 3 den Wert 5 und bleibt erhalten. Index 2 enthält 8 und wird entfernt. Index 1 enthält weiterhin die andere 8 und wird als Nächstes entfernt. Index 0 enthält 3 und bleibt erhalten. Das Ergebnis ist [3, 5]. Das Entfernen verschiebt Elemente rechts vom aktuellen Index, die diese rückwärts gerichtete Schleife bereits geprüft hat.

Stelle die Werte zusammen, die erhalten bleiben sollen

Wenn das Original unverändert bleiben soll, erstelle eine neue Liste:

ArrayList<Integer> odds = new ArrayList<>();
for (int value : numbers) {
    if (value % 2 != 0) {
        odds.add(value);
    }
}

Diese for-each-Schleife ist sicher, weil sie numbers liest und Elemente zu einer anderen Liste hinzufügt. Mit [3, 8, 8, 5] als Eingabe enthält odds den Wert [3, 5] und die Eingabe weiterhin alle vier Werte. Auch ein Array kann nicht schrumpfen; zum Filtern seiner Werte brauchst du ebenfalls ein neues Array oder eine neue Liste.

Lass einen Iterator das Entfernen selbst verwalten

Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) {
        it.remove();
    }
}

Importiere java.util.Iterator. next() liefert das nächste Element, und it.remove() entfernt das gerade zurückgegebene Element und hält dabei die Position des Iterators konsistent. Ersetze es in dieser Schleife nicht durch numbers.remove(...).

Auch eine vorwärts gerichtete while-Schleife kann funktionieren, wenn sie nur weiterzählt, falls nichts entfernt wurde. Nach dem Entfernen muss sie denselben Index erneut prüfen, an den das nächste Element gerückt ist. Das erfordert mehr Sorgfalt als eine rückwärts gerichtete Schleife oder eine neue Ergebnisliste.

Ersetzen und Hinzufügen wirken unterschiedlich

set(i, value) ist in einer indexbasierten Schleife sicher, weil sich weder Größe noch Positionen ändern. Wenn du bei jedem Durchlauf ein Element hinzufügst und dabei i < list.size() prüfst, kann sich das Ende immer weiter verschieben und die Schleife endlos laufen. Speichere int originalSize = list.size(); und durchlaufe die Liste nur bis zu dieser Schleifengrenze, wenn jedes ursprüngliche Element einen angehängten Wert erzeugen soll.

Ein String speichert Text als Folge von char-Werten. Die Indizes beginnen wie bei Arrays und Listen bei 0. Ein String-Objekt kann nach seiner Erstellung nicht verändert werden. Methoden, die geänderten Text erzeugen, geben daher ein Ergebnis zurück, das du speichern musst.

Ein Zeichen unterscheidet sich von einem String

"Hello".length() ist 5. "Hello".charAt(0) ist 'H' und charAt(4) ist 'o'. Ein char verwendet einfache Anführungszeichen und enthält eine UTF-16-Codeeinheit; ein String verwendet doppelte Anführungszeichen und kann null, eine oder viele solcher Einheiten enthalten. "Java".charAt(0) == 'J' vergleicht zwei primitive Zeichen. Der Vergleich dieses char mit "J" lässt sich nicht kompilieren, weil die Typen verschieden sind.

charAt(length()) liegt hinter dem Ende und löst eine StringIndexOutOfBoundsException aus. Selbst charAt(0) schlägt bei "" fehl. Prüfe isEmpty(), bevor du das erste Zeichen einer Eingabe liest.

length() zählt UTF-16-char-Werte, die nicht immer vollständige angezeigte Symbole sind. "café".length() ist 4; "Hi 👋".length() ist 5, weil das Emoji mit der winkenden Hand zwei char-Positionen belegt. Verwende diese Zählweise, wenn du die Indizes dieser Methoden nachvollziehst.

Durchlaufe und prüfe die Zeichen

String text = "Programming in Java".toLowerCase();
int vowels = 0;
for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);
    if ("aeiou".indexOf(c) >= 0) {
        vowels++;
    }
}

Durch die Umwandlung in Kleinbuchstaben erkennt dieselbe Prüfung der Zugehörigkeit große und kleine Vokale. Jeder Aufruf von indexOf(c) ergibt einen nicht negativen Wert, wenn das Zeichen in "aeiou" vorkommt. Der Zähler erreicht 6: o, a, i, i, a, a. for (char c : text.toCharArray()) kann dieselben Werte ohne Index durchlaufen.

Die Klasse Character stellt Prüfungen wie isLetter, isDigit, isWhitespace und isUpperCase bereit. Character.isDigit('7') ist true, während Character.isLetter('7') false ist. Character.toUpperCase(c) und toLowerCase(c) geben umgewandelte char-Werte zurück.

Zeichen haben auch numerische Codes. 'a' + 1 ergibt den int 98; (char) ('a' + 1) wandelt diesen Code in 'b' um. Bei einem ASCII-Ziffernzeichen ergibt das Abziehen von '0' seinen Wert: '7' - '0' ist 7. Das Abziehen des Codes für null funktioniert, weil diese Zifferncodes aufeinanderfolgen.

Lies Konkatenationen von links nach rechts

Sobald die linke Seite von + Text ist, wird die nächste Zahl als Text angefügt. Klammern erzwingen die numerische Addition vor dem Verknüpfen. Für wenige Verknüpfungen in einem Ausdruck ist + eine übersichtliche Lösung.

Speichere den zurückgegebenen Text

String name = "Lena";
name.toUpperCase();
System.out.println(name);
name = name.toUpperCase();

Die Ausgabe zeigt weiterhin "Lena": Der verworfene Aufruf hat das Objekt nicht verändert. Durch die anschließende Zuweisung verweist name auf "LENA". Die Unveränderlichkeit von Strings bedeutet, dass der alte Text unverändert bleibt, selbst wenn andere Variablen darauf verweisen. Das Speichern des Ergebnisses und das Ändern des ursprünglichen Objekts sind verschiedene Vorgänge.

Die Textverarbeitung folgt oft einer kurzen Abfolge: Finde eine Markierung, prüfe, ob sie vorhanden ist, und extrahiere dann den benötigten Teil. Bereinigungsoperationen können den Text vor einer Suche oder einem Vergleich vorbereiten. Jede String-Operation gibt ein Ergebnis zurück, ohne ihr ursprüngliches Objekt zu ändern.

Finde Positionen oder stelle eine Ja-Nein-Frage

Für "banana" gibt indexOf('a') den Wert 1 zurück, indexOf("a", 2) den Wert 3 und lastIndexOf('a') den Wert 5. Das zweite Argument legt fest, wo die Vorwärtssuche beginnt. Eine erfolglose Suche ergibt -1, wie bei indexOf("x").

Verwende contains(text), wenn du nur wissen musst, ob Text vorkommt. startsWith(prefix) prüft den Anfang und endsWith(suffix) das Ende. "report.pdf".endsWith(".pdf") ist true. Diese Suchen beachten die Groß- und Kleinschreibung: "Hello".contains("hello") ist false. Die Indexmethoden akzeptieren einen char oder einen String; contains nimmt Text entgegen.

Ein Teilstring endet unmittelbar vor seinem Endindex

String word = "programming";
String middle = word.substring(3, 7);
String tail = word.substring(3);

middle ist "gram" und verwendet die Positionen 3, 4, 5 und 6. Seine Länge ist 7 - 3, also 4. tail ist "gramming", weil das Weglassen des Endarguments den Teilstring bis zum Ende des Strings reichen lässt. Der Anfang muss nicht negativ und darf nicht größer als das Ende sein; das Ende darf length() nicht überschreiten. Ungültige Schranken lösen eine StringIndexOutOfBoundsException aus.

Finde bei einer E-Mail-Adresse vor dem Ausschneiden das Trennzeichen:

String email = "lena.ito@example.com";
int at = email.indexOf("@");
if (at != -1) {
    String user = email.substring(0, at);
    String domain = email.substring(at + 1);
}

Das Trennzeichen steht an Index 8. Der erste Ausschnitt endet davor und ergibt "lena.ito"; der zweite beginnt danach und ergibt "example.com". Fehlt die Markierung, ist at gleich -1. Ein Aufruf von substring(0, at) ohne die Prüfung würde fehlschlagen. Würde der zweite Ausschnitt bei at beginnen, bliebe das @ in der Domain erhalten.

Bereinige nur das, worauf die Operation zielt

" hello ".trim() ergibt "hello"; innere Leerzeichen bleiben erhalten. strip() behandelt zusätzlichen Unicode-Leerraum wie ein Geviert. Die Methode verwendet Javas Leerraumdefinition, die nicht jedes Zeichen einschließt, das wie ein Leerzeichen aussieht. "banana".replace('a', 'o') ergibt "bonono". "ab".repeat(3) ergibt "ababab".

Leer und nur aus Leerraum bestehend sind verschieden

isEmpty() prüft auf Länge 0. isBlank() akzeptiert auch Text, der nur aus Java-Leerraum besteht. Für " " ist die erste Prüfung false und die zweite true. Verwende die Prüfung, die zur Eingaberegel passt. Um eine Antwort wie " Yes " zu bereinigen, gibt answer.trim().toLowerCase() den Wert "yes" zurück. Speichere den zurückgegebenen Text, wenn die Variable den bereinigten Wert behalten soll; ein allein stehendes answer.trim(); verwirft ihn.

Eine Datenzeile kann mehrere Werte enthalten, die durch ein Komma oder eine andere Markierung getrennt sind. Das Aufteilen erzeugt ein Array von Strings; das anschließende Parsen wandelt ausgewählte Datenfelder in Zahlen um. Prüfe die Struktur der Daten, bevor du auf ihre Positionen zugreifst.

Teile in ein Array auf

String[] fields = "Ada,36,London".split(",");

Es gibt drei Datenfelder: "Ada", "36" und "London". Die Kommas bleiben nicht erhalten. fields.length ist 3 und fields[1] ist weiterhin Text, keine Zahl.

Das an split übergebene Trennzeichen ist ein regulärer Ausdruck, also ein Muster und nicht immer literaler Text. Ein Komma steht für sich selbst, aber ., |, *, + und ? haben besondere Bedeutungen. Um eine Versionszeichenfolge an tatsächlichen Punkten zu trennen, verwende "1.5.2".split("\\."). Zwei umgekehrte Schrägstriche im Java-String erzeugen den einen umgekehrten Schrägstrich im Muster, der den Punkt als tatsächliches Zeichen behandelt. split(".") trifft stattdessen auf einzelne Zeichen zu und erzeugt in diesem Beispiel ein leeres Array.

Behandle Leerzeichen und leere Teile

Das Aufteilen von "a b" an " " erzeugt drei Teile: "a", "" und "b". Jedes Trennzeichen ist ein Leerzeichen, sodass benachbarte Leerzeichen einen leeren Teil zwischen sich lassen. Verwende für Folgen von Leerraum:

String[] words = "  red   green blue ".trim().split("\\s+");

Das Ergebnis ist [red, green, blue]. Die vorherige Bereinigung mit trim verhindert einen leeren ersten Teil durch ein führendes Trennzeichen. Standardmäßig verwirft split leere Teile am Ende: "a,b,,".split(",") ergibt nur "a" und "b". Zähle die tatsächlich entstandenen Datenfelder, bevor du über Indizes darauf zugreifst.

Parse jedes Datenfeld in den vorgesehenen Typ

Integer.parseInt("42") gibt den primitiven int 42 zurück. Integer.valueOf("-7") gibt ein Integer-Objekt zurück. Double.parseDouble("5.2") gibt 5,2 zurück und verwendet unabhängig von den Ländereinstellungen des Computers einen Punkt als Dezimaltrennzeichen. Das Parsen von Ganzzahlen akzeptiert Ganzzahltext ohne Dezimalpunkt. Integer.parseInt("4.5") schlägt fehl, statt zu runden.

Bereinige Datenfelder vor dem Parsen mit trim, besonders bei Ganzzahltext: Integer.parseInt(" 42") löst eine NumberFormatException aus. Das Aufteilen an Kommas entfernt keine Leerzeichen um die Datenfelder. Auch eine korrekte Anzahl von Datenfeldern garantiert nicht, dass ein Feld eine gültige Zahl enthält.

Lies einen vollständigen Datensatz

String line = "Amira,10.5,63";
String[] parts = line.split(",");
if (parts.length == 3) {
    String name = parts[0].trim();
    double distanceKm = Double.parseDouble(parts[1].trim());
    int minutes = Integer.parseInt(parts[2].trim());
    double pace = minutes / distanceKm;
    System.out.println(name + ": " + pace + " min/km");
}

Die Strecke beträgt 10,5 km, die Zeit 63 Minuten und das Lauftempo 6,0 min/km. Die unvollständige Zeile "Amira,10.5" hat nur zwei Datenfelder; ohne die Prüfung der Anzahl würde parts[2] eine ArrayIndexOutOfBoundsException auslösen. Ein Programm kann diesen unvollständigen Datensatz überspringen oder melden, bevor es auf eine fehlende Position zugreift.

Wandle Text wieder um oder füge ihn zusammen

String.valueOf(42) und Integer.toString(42) ergeben beide "42". String.join(", ", List.of("Oslo", "Lima", "Pune")) ergibt "Oslo, Lima, Pune" und fügt Trennzeichen nur zwischen den Teilen ein. Die Methode akzeptiert eine Liste, ein Array oder einzelne String-Argumente. Das Zusammenfügen parst oder berechnet nichts: Es verbindet die übergebenen Strings.

Zwei Variablen können Text mit denselben Zeichen enthalten, ohne auf dasselbe String-Objekt zu verweisen. Wähle den Vergleich passend zur Frage: gleicher Inhalt, gleicher Inhalt ohne Beachtung der Groß- und Kleinschreibung oder welcher Text in Javas Ordnung zuerst kommt.

Verwende equals für Inhalte

String answer = new String("yes");
System.out.println(answer == "yes");
System.out.println(answer.equals("yes"));

Das erste Ergebnis ist false: Das separat erstellte Objekt ist nicht das Objekt des Literals. Das zweite ist true, weil die Zeichen übereinstimmen. Identische Literale wie in "yes" == "yes" nutzen ein Objekt gemeinsam und können den Identitätsvergleich zuverlässig erscheinen lassen. Während der Laufzeit entstandener Text kann neue oder vorhandene Objekte verwenden, daher eignet sich die Identität nicht, um übereinstimmende Eingaben zu prüfen.

equalsIgnoreCase ignoriert die Groß- und Kleinschreibung: "YES".equalsIgnoreCase("yes") ist true. Die Methode entfernt keine Leerzeichen. Um auch umgebende Leerzeichen zu akzeptieren, bereinige die Eingabe vor dem Vergleich.

Bei einer Variable, die null sein könnte, rufe die Methode auf einem bekannten Literal auf, das nicht null ist: "yes".equals(answer) gibt für null den Wert false zurück. answer.equals("yes") löst eine NullPointerException aus, wenn answer null ist, weil kein Objekt den Aufruf empfängt.

Eine Befehlsschleife kann !command.equals("quit") prüfen. Das ! negiert die inhaltliche Gleichheit. command != "quit" prüft stattdessen Referenzen und kann eine Schleife am Laufen halten, selbst wenn die eingegebenen Zeichen „quit“ lauten.

Deute das Vorzeichen von compareTo

a.compareTo(b) vergleicht UTF-16-char-Werte der Reihe nach. Die Methode gibt eine negative Zahl zurück, wenn a vor b steht, null bei Gleichheit und eine positive Zahl, wenn es danach steht. Für die Ordnung zählt nur das Vorzeichen; ein Ergebnis muss nicht genau -1 oder 1 sein.

Als Text gespeicherte Zahlen folgen daher nicht der numerischen Reihenfolge. Parse sie, wenn die Aufgabe numerisch ist. Akzentlose englische Großbuchstaben stehen vor akzentlosen Kleinbuchstaben, daher kommt "Zebra" vor "apple". "Émile" mit Akzent kommt in dieser Ordnung nach "Zoe". compareToIgnoreCase ignoriert die Groß- und Kleinschreibung; für eine sprachspezifische Wörterbuchordnung brauchst du java.text.Collator.

Verwende das Minimummuster erneut für Namen

Für eine nicht leere Liste [Mia, Ahmed, Lucia]:

String first = names.get(0);
for (String name : names) {
    if (name.compareTo(first) < 0) {
        first = name;
    }
}

"Mia" ist der erste Kandidat. "Ahmed" steht im Vergleich davor und wird zum Kandidaten; "Lucia" ersetzt ihn nicht. Das Ergebnis ist "Ahmed". Prüfe auf eine leere Liste, bevor du ihr erstes Element liest.

Ein einzelner char ist ein primitiver Wert, daher ist word.charAt(0) == 'A' ein korrekter Zeichenvergleich, sobald feststeht, dass das Wort nicht leer ist. Das Problem mit == betrifft die Objektidentität, nicht jeden Vergleich mit Text.

Ein StringBuilder enthält veränderlichen Text. Er ist nützlich, wenn eine Schleife viele Teile hinzufügt oder wenn Zeichen direkt bearbeitet werden müssen. Wenige Verknüpfungen in einem Ausdruck sind mit + übersichtlich, aber das wiederholte Neuerstellen eines wachsenden Strings kann dessen angesammelten Inhalt oft kopieren.

Hänge Teile an und schließe mit einem String ab

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        sb.append(", ");
    }
    sb.append(i);
}
String result = sb.toString();

Ein Import ist nicht nötig. append hängt Strings, chars, Zahlen oder boolesche Werte am Ende an. Der erste Durchlauf fügt nur 1 hinzu; der zweite fügt ", " und dann 2 hinzu. Das Ergebnis ist "1, 2, 3, 4, 5". Ein Trennzeichen nach jeder Zahl würde ein unerwünschtes Trennzeichen am Ende hinterlassen. Für eine vorhandene Liste von Strings behandelt String.join(", ", list) die Trennzeichen direkt.

Wiederholtes text += piece in einer Schleife erzeugt neue unveränderliche String-Ergebnisse. Das angesammelte Präfix muss jedes Mal übernommen werden, sodass die kopierte Datenmenge beim Wachsen eines langen Ergebnisses quadratisch wachsen kann. Ein Builder verwaltet einen veränderlichen Puffer und hängt daran an, ohne bei jedem Durchlauf das gesamte Präfix neu aufzubauen.

Bearbeite Positionen und Bereiche

length() und charAt(i) lesen den Builder wie einen String. Indizes beschreiben seinen aktuellen Zustand; ein Einfügen oder Löschen kann spätere Positionen ändern.

Beginne mit new StringBuilder("Jva"). insert(1, 'a') ergibt "Java"; setCharAt(0, 'j') ergibt anschließend "java". Bei "2026-10-22" entfernt delete(4, 7) die Positionen 4, 5 und 6 und hinterlässt "2026-22". Das Ersetzen der Positionen 7 bis 9 in "I like tea" durch "coffee" ergibt "I like coffee".

Verkette nur Methoden, die den Builder zurückgeben

new StringBuilder().append("a").append(1).append('b').toString() ergibt "a1b". Die append-Aufrufe geben denselben Builder zurück und ermöglichen so einen weiteren Aufruf. Auch die hier genannten Bearbeitungsmethoden geben den Builder zurück, außer setCharAt: Diese Methode gibt void zurück und benötigt eine separate Anweisung.

reverse() ändert das Empfängerobjekt. Enthält sb den Text "stressed", hinterlässt String r = sb.reverse().toString(); sowohl in r als auch im Text des Builders den Wert "desserts". Um den ursprünglichen Builder zu erhalten, kehre einen neuen Builder um, der aus seinem Text erstellt wurde.

Vergleiche fertige Inhalte

Hänge für eine Palindromprüfung die Kleinschreibung jedes Buchstabens aus "Was it a car or a cat I saw" an. Der bereinigte Text ist "wasitacaroracatisaw". Kehre einen neuen Builder mit diesem Text um, wandle ihn in einen String um und vergleiche mit clean.equals(reversed). Der Vergleich ist true.

StringBuilder überschreibt equals nicht für den Inhaltsvergleich. Separate Builder mit dem Inhalt "abc" sind nach dieser Methode nicht gleich, und ein Builder ist nicht gleich einem String. Wandle zuerst um: sb1.toString().equals(sb2.toString()) vergleicht den tatsächlichen Text.