Zum Inhalt springen

Strings

Texte begegnen dir in fast jedem Programm: Namen, Eingaben, Dateizeilen, Meldungen. Die Klasse String bringt dafür eine ganze Werkzeugkiste mit. In diesem Kapitel lernst du die wichtigsten Werkzeuge kennen – und wie du selbst herausfindest, was es sonst noch gibt.

  • die wichtigsten Methoden von String anwenden
  • erklären, warum ein String sich nie ändert
  • einen Text Zeichen für Zeichen untersuchen
  • Texte zerlegen und effizient zusammenbauen
  • in der API-Dokumentation nachschlagen

Ein String ist ein Objekt – und Objekte haben Methoden. Anders als bei Math.max(…) ruft man sie nicht über den Klassennamen auf, sondern über das Objekt selbst: text.length(). Die Methode arbeitet dann mit diesem Text.

Textmethoden.java
package de.drv;
public class Textmethoden {
public static void main(String[] args) {
String text = "Deutsche Rentenversicherung";
System.out.println(text.length());
System.out.println(text.charAt(0));
System.out.println(text.indexOf("Rente"));
System.out.println(text.indexOf("Pension"));
System.out.println(text.contains("versicherung"));
System.out.println(text.startsWith("Deutsch"));
System.out.println(text.endsWith("ung"));
System.out.println(text.substring(9));
System.out.println(text.substring(9, 14));
System.out.println(text.toUpperCase());
System.out.println(text.toLowerCase());
System.out.println(text.replace("Renten", "Kranken"));
}
}
Terminal-Fenster
27
D
9
-1
true
true
true
Rentenversicherung
Rente
DEUTSCHE RENTENVERSICHERUNG
deutsche rentenversicherung
Deutsche Krankenversicherung
Methode liefert
length() Anzahl der Zeichen
charAt(i) das Zeichen an Position i (ab 0) – ein char
indexOf(t) Position, an der t zum ersten Mal vorkommt – oder -1
contains(t) true, wenn t vorkommt
startsWith(t), endsWith(t) true, wenn der Text so beginnt bzw. endet
substring(von) Teiltext ab Position von bis zum Ende
substring(von, bis) Teiltext von von bis vor bis
toUpperCase(), toLowerCase() Text in Groß- bzw. Kleinbuchstaben
replace(alt, neu) Text, in dem jedes alt durch neu ersetzt ist
equals(t), equalsIgnoreCase(t) Vergleich – siehe Referenzen
Eingabe.java
package de.drv;
public class Eingabe {
public static void main(String[] args) {
String eingabe = " Max Mustermann ";
System.out.println("[" + eingabe + "]");
System.out.println("[" + eingabe.strip() + "]");
System.out.println(eingabe.isBlank());
System.out.println("".isEmpty());
System.out.println("-".repeat(20));
}
}
Terminal-Fenster
[ Max Mustermann ]
[Max Mustermann]
false
true
--------------------
  • strip() entfernt Leerzeichen am Anfang und am Ende – nützlich bei Eingaben. In älterem Code findest du dafür trim().
  • isEmpty() ist true bei einem Text ohne Zeichen, isBlank() auch dann, wenn er nur aus Leerzeichen besteht.
  • repeat(n) wiederholt den Text n-mal.
Unveraenderlich.java
package de.drv;
public class Unveraenderlich {
public static void main(String[] args) {
String name = "anna";
name.toUpperCase();
System.out.println(name);
name = name.toUpperCase();
System.out.println(name);
}
}
Terminal-Fenster
anna
ANNA

Ein String-Objekt kann sich nie ändern. Methoden wie toUpperCase, replace oder strip verändern deshalb nicht den Text, sondern liefern einen neuen. Wer das Ergebnis nicht speichert, verliert es – Eclipse warnt dabei nicht.

Mit length() und charAt(i) lässt sich ein Text wie ein Array durchlaufen. Für die einzelnen Zeichen hat die Klasse Character nützliche Prüfmethoden:

Zeichen.java
package de.drv;
public class Zeichen {
public static void main(String[] args) {
String passwort = "Sommer2026!";
int ziffern = 0;
int grossbuchstaben = 0;
for (int i = 0; i < passwort.length(); i++) {
char c = passwort.charAt(i);
if (Character.isDigit(c)) {
ziffern++;
} else if (Character.isUpperCase(c)) {
grossbuchstaben++;
}
}
System.out.println("Ziffern: " + ziffern);
System.out.println("Großbuchstaben: " + grossbuchstaben);
}
}
Terminal-Fenster
Ziffern: 4
Großbuchstaben: 1
Methode prüft bzw. liefert
Character.isDigit(c) Ist c eine Ziffer?
Character.isLetter(c) Ist c ein Buchstabe?
Character.isUpperCase(c), isLowerCase(c) Groß- bzw. Kleinbuchstabe?
Character.isWhitespace(c) Leerzeichen, Tabulator, Zeilenumbruch?
Character.toUpperCase(c) das Zeichen als Großbuchstabe
Zerlegen.java
package de.drv;
import java.util.Arrays;
public class Zerlegen {
public static void main(String[] args) {
String zeile = "Anna;Ben;Clara;David";
String[] teile = zeile.split(";");
System.out.println(teile.length);
System.out.println(Arrays.toString(teile));
String wieder = String.join(", ", teile);
System.out.println(wieder);
}
}
Terminal-Fenster
4
[Anna, Ben, Clara, David]
Anna, Ben, Clara, David
  • split(trenner) zerlegt einen Text an jedem Trennzeichen und liefert ein Array.
  • String.join(trenner, teile) setzt ein Array wieder zu einem Text zusammen.

Weil Strings unveränderlich sind, erzeugt jedes + einen neuen Text. In einer Schleife mit vielen Durchläufen ist das verschwenderisch. Dafür gibt es den StringBuilder – einen Text, der sich verändern lässt:

Zusammenbauen.java
package de.drv;
public class Zusammenbauen {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
sb.append(i);
if (i < 5) {
sb.append(" - ");
}
}
String ergebnis = sb.toString();
System.out.println(ergebnis);
String umgedreht = new StringBuilder("Rentenversicherung").reverse().toString();
System.out.println(umgedreht);
}
}
Terminal-Fenster
1 - 2 - 3 - 4 - 5
gnurehcisrevnetneR
  • append(…) hängt etwas an – Text, Zahlen, Zeichen.
  • reverse() dreht den Inhalt um.
  • toString() liefert am Ende den fertigen String.
Formatieren.java
package de.drv;
public class Formatieren {
public static void main(String[] args) {
String name = "Anna";
int punkte = 87;
String zeile1 = String.format("%s hat %d Punkte.", name, punkte);
String zeile2 = "%s hat %d Punkte.".formatted(name, punkte);
System.out.println(zeile1);
System.out.println(zeile2);
String brief = """
Sehr geehrte Frau Muster,
vielen Dank für Ihre Nachricht.
""";
System.out.print(brief);
}
}
Terminal-Fenster
Anna hat 87 Punkte.
Anna hat 87 Punkte.
Sehr geehrte Frau Muster,
vielen Dank für Ihre Nachricht.
  • String.format und formatted kennen dieselben Platzhalter wie printf – geben das Ergebnis aber als Text zurück, statt es auszugeben.
  • Ein Textblock zwischen """ darf über mehrere Zeilen gehen. Die Einrückung, die alle Zeilen gemeinsam haben, wird entfernt.

String hat weit mehr Methoden, als hier Platz haben. Alle Klassen der Standardbibliothek sind ausführlich dokumentiert – in der API-Dokumentation (auch Javadoc):

  • Im Browser: Java 21 API – Klasse String. Oben steht, was die Klasse ist und wofür man sie benutzt. Darunter folgt die Method Summary: eine Tabelle aller Methoden mit Rückgabetyp, Name, Parametern und einer Kurzbeschreibung. Ein Klick auf den Namen führt zur ausführlichen Beschreibung.
  • In Eclipse: Tippst du text. und wartest, zeigt die Vervollständigung zu jeder Methode die Beschreibung an. Fährst du mit der Maus über einen Methodenaufruf, erscheint die Dokumentation ebenfalls.

Du erkennst dort das Format wieder, das du im Kapitel Statische Methoden selbst geschrieben hast: Beschreibung, Parameter, Rückgabewert.

Meldung bzw. Symptom Ursache
StringIndexOutOfBoundsException: Index 5 out of bounds for length 3 charAt mit einer Position außerhalb des Texts
StringIndexOutOfBoundsException: Range [2, 5) out of bounds for length 3 substring reicht über das Ende hinaus
Text bleibt unverändert Ergebnis von toUpperCase, replace, strip … nicht gespeichert
NullPointerException beim Methodenaufruf Die Variable ist null
length cannot be resolved or is not a field length ohne Klammern – bei Texten heißt es length()
  1. Lies einen Text ein und prüfe, ob er ein Palindrom ist – also vorwärts und rückwärts gleich gelesen wird. Groß-/Kleinschreibung und Leerzeichen sollen keine Rolle spielen. Teste mit „Lagerregal“ und „Erika feuert nur untreue Fakire“.

    Lösung
    Palindrom.java
    package de.drv;
    import java.util.Scanner;
    public class Palindrom {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Text: ");
    String text = scanner.nextLine();
    String bereinigt = text.toLowerCase().replace(" ", "");
    String umgedreht = new StringBuilder(bereinigt).reverse().toString();
    if (bereinigt.equals(umgedreht)) {
    System.out.println("\"" + text + "\" ist ein Palindrom.");
    } else {
    System.out.println("\"" + text + "\" ist kein Palindrom.");
    }
    scanner.close();
    }
    }
  2. Zähle die Vokale (a, e, i, o, u, ä, ö, ü) in einem eingelesenen Text.

    Lösung

    Ein kleiner Trick: "aeiouäöü".indexOf(c) ist -1, wenn c kein Vokal ist. So spart man sich eine lange Bedingung.

    Vokale.java
    package de.drv;
    import java.util.Scanner;
    public class Vokale {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Text: ");
    String text = scanner.nextLine().toLowerCase();
    int anzahl = 0;
    for (int i = 0; i < text.length(); i++) {
    if ("aeiouäöü".indexOf(text.charAt(i)) >= 0) {
    anzahl++;
    }
    }
    System.out.println("Vokale: " + anzahl);
    scanner.close();
    }
    }
  3. Lies einen vollständigen Namen ein und gib die Initialen aus: aus „max peter Mustermann“ wird „M. P. M.“.

    Lösung
    Initialen.java
    package de.drv;
    import java.util.Scanner;
    public class Initialen {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Vollständiger Name: ");
    String[] teile = scanner.nextLine().strip().split("\\s+");
    StringBuilder initialen = new StringBuilder();
    for (String teil : teile) {
    initialen.append(Character.toUpperCase(teil.charAt(0))).append(". ");
    }
    System.out.println(initialen.toString().strip());
    scanner.close();
    }
    }
  4. Lies einen Satz ein und gib die Wörter in umgekehrter Reihenfolge aus: aus „Java macht Spaß“ wird „Spaß macht Java“.

    Lösung
    WoerterUmdrehen.java
    package de.drv;
    import java.util.Scanner;
    public class WoerterUmdrehen {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Satz: ");
    String[] woerter = scanner.nextLine().strip().split("\\s+");
    StringBuilder ergebnis = new StringBuilder();
    for (int i = woerter.length - 1; i >= 0; i--) {
    ergebnis.append(woerter[i]);
    if (i > 0) {
    ergebnis.append(" ");
    }
    }
    System.out.println(ergebnis);
    scanner.close();
    }
    }
  5. Versicherungsnummer: Eine Versicherungsnummer der Rentenversicherung hat 12 Zeichen: 2 Ziffern Bereichsnummer, 6 Ziffern Geburtsdatum (TTMMJJ), 1 Buchstabe, 2 Ziffern Seriennummer und 1 Prüfziffer. Zerlege die – erfundene – Nummer 12 150505 M 01 2 in ihre Bestandteile und gib das Geburtsdatum als 15.05.05 aus. Die Prüfziffer lassen wir außen vor.

    Lösung

    Zuerst werden die Leerzeichen entfernt – danach stehen alle Teile an festen Positionen und lassen sich mit substring und charAt herauslösen.

    Versicherungsnummer.java
    package de.drv;
    public class Versicherungsnummer {
    public static void main(String[] args) {
    String eingabe = "12 150505 M 01 2";
    String nummer = eingabe.replace(" ", "");
    if (nummer.length() != 12) {
    System.out.println("Eine Versicherungsnummer hat 12 Zeichen.");
    return;
    }
    String bereich = nummer.substring(0, 2);
    String tag = nummer.substring(2, 4);
    String monat = nummer.substring(4, 6);
    String jahr = nummer.substring(6, 8);
    char buchstabe = nummer.charAt(8);
    String serie = nummer.substring(9, 11);
    char pruefziffer = nummer.charAt(11);
    System.out.println("Bereichsnummer: " + bereich);
    System.out.println("Geburtsdatum: " + tag + "." + monat + "." + jahr);
    System.out.println("Buchstabe: " + buchstabe);
    System.out.println("Seriennummer: " + serie);
    System.out.println("Prüfziffer: " + pruefziffer);
    }
    }
  6. Passwort-Prüfung: Lies ein Passwort ein und prüfe: mindestens 8 Zeichen, mindestens eine Ziffer, ein Groß- und ein Kleinbuchstabe. Gib aus, welche Regeln nicht erfüllt sind.

    Lösung
    Passwort.java
    package de.drv;
    import java.util.Scanner;
    public class Passwort {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Passwort: ");
    String passwort = scanner.nextLine();
    boolean ziffer = false;
    boolean gross = false;
    boolean klein = false;
    for (int i = 0; i < passwort.length(); i++) {
    char c = passwort.charAt(i);
    if (Character.isDigit(c)) {
    ziffer = true;
    } else if (Character.isUpperCase(c)) {
    gross = true;
    } else if (Character.isLowerCase(c)) {
    klein = true;
    }
    }
    boolean ok = true;
    if (passwort.length() < 8) {
    System.out.println("- mindestens 8 Zeichen");
    ok = false;
    }
    if (!ziffer) {
    System.out.println("- mindestens eine Ziffer");
    ok = false;
    }
    if (!gross) {
    System.out.println("- mindestens ein Großbuchstabe");
    ok = false;
    }
    if (!klein) {
    System.out.println("- mindestens ein Kleinbuchstabe");
    ok = false;
    }
    if (ok) {
    System.out.println("Das Passwort erfüllt alle Regeln.");
    }
    scanner.close();
    }
    }
  7. Zähle die Wörter in einem eingelesenen Satz. Mehrere Leerzeichen hintereinander sollen nicht stören.

    Lösung

    Vorsicht bei einer leeren Eingabe: "".split("\\s+") liefert ein Array mit einem leeren Text – deshalb wird dieser Fall vorher abgefangen.

    Woerter.java
    package de.drv;
    import java.util.Scanner;
    public class Woerter {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Satz: ");
    String satz = scanner.nextLine().strip();
    if (satz.isEmpty()) {
    System.out.println("Wörter: 0");
    } else {
    String[] woerter = satz.split("\\s+");
    System.out.println("Wörter: " + woerter.length);
    }
    scanner.close();
    }
    }