Java-Strings: erstellen, verketten und String-Methoden nutzen

Was ein String ist

Ein String enthält eine Folge von Zeichen - Text wie ein Name, ein Satz oder eine aus einer Datei gelesene Zeile. Auf der vorigen Seite hast du String unter den Referenztypen aufgeführt gesehen; hier arbeitest du nun tatsächlich mit einem. Ein String-Literal schreibst du mit doppelten Anführungszeichen (einfache Anführungszeichen sind für ein einzelnes char reserviert):

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

name.length() gibt die Anzahl der Zeichen zurück - 3 für "Ada". Es ist ein Methodenaufruf, daher braucht es die Klammern.

Strings verbinden

Der +-Operator klebt Strings aneinander. Wenn eine der beiden Seiten von + ein String ist, wird die andere Seite automatisch in Text umgewandelt, sodass du ohne zusätzlichen Aufwand Zahlen und Booleans einmischen kannst:

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

Ein Fallstrick: Da + von links nach rechts ausgewertet wird, ergibt "" + 1 + 2 den Wert "12" (String + int, dann String + int), aber 1 + 2 + "" ergibt "3" (die beiden Ganzzahlen werden zuerst addiert und dann in Text umgewandelt). Im Zweifelsfall setzt du die Arithmetik in Klammern.

Strings sind unveränderlich

Das ist das Wichtigste, was man über Java-Strings verstehen muss: Ein String ändert sich nach seiner Erstellung nie. Jede Methode, die einen String „verändert", gibt in Wirklichkeit einen brandneuen String zurück und lässt das Original unberührt. Wenn du also vergisst, den Rückgabewert zu erfassen, passiert nichts:

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // Ergebnis verworfen - Bug!
        System.out.println(s);        // immer noch "hello"

        s = s.toUpperCase();          // den neuen String erfassen
        System.out.println(s);        // jetzt "HELLO"
    }
}

Der erste Aufruf berechnet "HELLO" und verwirft es sofort. Nur die zweite Zeile, die wieder in s zuweist, hat einen sichtbaren Effekt. In diese Falle tappt fast jeder einmal.

Strings vergleichen

Verwende .equals(), um den Inhalt zweier Strings zu vergleichen. Zu == zu greifen ist der klassische Anfängerfehler: == fragt „sind das dasselbe Objekt im Speicher?", nicht „enthalten sie denselben Text?":

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

a == b ist hier false, weil new String(...) ein separates Objekt erzwingt. Vergleiche String-Werte immer mit .equals() (oder .equalsIgnoreCase(), um Groß- und Kleinschreibung zu ignorieren). Ein praktischer Trick, um einen Absturz zu vermeiden, wenn eine Seite null sein könnte, ist, .equals auf dem Literal aufzurufen: "yes".equals(input) wirft nie eine Exception, selbst wenn input gleich null ist.

Alltägliche String-Methoden

Da Strings unveränderlich sind, gibt jede dieser Methoden einen neuen String (oder einen Wert) zurück, anstatt das Original zu ändern. Das sind die, zu denen du ständig greifen wirst:

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

Beachte die Verkettung: s.trim().toUpperCase() funktioniert, weil trim() einen String zurückgibt, auf dem du dann toUpperCase() aufrufst. substring ist ein weiteres Arbeitspferd - es nimmt einen Startindex (inklusive) und einen optionalen Endindex (exklusive):

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

Die Indizes sind nullbasiert, also greift substring(0, 4) die Zeichen 0 bis 3. Einen Index jenseits des Endes anzufordern, wirft eine StringIndexOutOfBoundsException.

Strings in einer Schleife aufbauen

Das Verketten mit + ist für ein paar Teile in Ordnung, aber innerhalb einer großen Schleife ist es langsam - jedes + erzeugt einen neuen String und kopiert alles. Wenn du Text in einer Schleife zusammensetzt, verwende StringBuilder, der einen Puffer an Ort und Stelle verändert und am Ende den fertigen String genau einmal erzeugt:

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

append gibt denselben Builder zurück, sodass sich die Aufrufe verketten lassen. Rufe am Ende .toString() auf, um einen normalen String zu erhalten. Für einmalige Zusammenfügungen bleib bei +; um viele Teile anzusammeln, ist StringBuilder das richtige Werkzeug.

Weiter: String-Formatierung

Verketten wird unübersichtlich, sobald du ausgerichtete Spalten, feste Nachkommastellen oder aufgefüllte Zahlen brauchst. Javas String.format und printf verwenden eine Vorlage mit %-Platzhaltern, um all das sauber zu erledigen - das ist Thema der nächsten Seite.