jario_
Anmelden
Zur Übersicht

Kapitel 5

Strings

Texte kennst du schon seit Kapitel 1. Ein String kann aber mehr als nur ausgegeben werden: Er weiß, wie lang er ist, du kannst Stücke herausschneiden, nach Zeichen suchen und ihn Zeichen für Zeichen durchgehen. Die Methoden dafür rufst du mit einem Punkt auf: text.length().

Länge, Ausschnitte, Suchen

Die wichtigsten Methoden:

  • length(): Anzahl der Zeichen
  • charAt(i): das Zeichen an Position i, gezählt ab 0 wie bei Arrays
  • substring(start, end): das Stück von start bis vor end; substring(start) nimmt alles bis zum Ende
  • indexOf('@'): Position des ersten Treffers, -1, wenn es keinen gibt
  • contains("Java"): true, wenn das Stück vorkommt
  • toUpperCase(), toLowerCase(): alles groß bzw. klein
  • trim(): Leerzeichen am Anfang und Ende entfernen

Ein String lässt sich nicht verändern. Alle diese Methoden liefern einen neuen String, der alte bleibt, wie er war. Deshalb gibt die letzte Zeile wieder Hello, Java! aus.

public class Main {
    public static void main(String[] args) {
        String text = "  Hello, Java!  ";
        String clean = text.trim();
        System.out.println("[" + clean + "]");
        System.out.println("Length: " + clean.length());
        System.out.println("First: " + clean.charAt(0));
        System.out.println("Last: " + clean.charAt(clean.length() - 1));

        System.out.println(clean.substring(0, 5));
        System.out.println(clean.substring(7));
        System.out.println(clean.indexOf(','));
        System.out.println(clean.indexOf('x'));
        System.out.println(clean.contains("Java"));

        System.out.println(clean.toUpperCase());
        System.out.println(clean);
    }
}

Zeichen für Zeichen

Ein einzelnes Zeichen hat den Typ char und steht in einfachen Anführungszeichen: 'a'. Zeichen vergleichst du mit ==. Mit einer for-Schleife von 0 bis length() - 1 und charAt(i) gehst du einen Text Zeichen für Zeichen durch.

Für einzelne Zeichen gibt es fertige Prüfungen: Character.isDigit(c), Character.isLetter(c) und Character.isUpperCase(c).

Hinter jedem char steckt eine Zahl, und die Buchstaben liegen der Reihe nach. Deshalb kannst du damit rechnen: 'c' - 'a' ergibt 2. Das Ergebnis ist ein int. Mit (char) davor wird wieder ein Zeichen daraus.

public class Main {
    public static void main(String[] args) {
        String password = "Secret42";
        int digits = 0;
        int upperCase = 0;
        for (int i = 0; i < password.length(); i++) {
            char c = password.charAt(i);
            if (Character.isDigit(c)) {
                digits++;
            }
            if (Character.isUpperCase(c)) {
                upperCase++;
            }
        }
        System.out.println("Digits: " + digits);
        System.out.println("Upper case: " + upperCase);

        char letter = 'c';
        int position = letter - 'a';
        System.out.println(letter + " is letter number " + (position + 1));
        char next = (char) (letter + 1);
        System.out.println("After " + letter + " comes " + next);
    }
}

Zerlegen und zusammenbauen

split(" ") zerlegt einen Text an jedem Leerzeichen und liefert ein String[] mit den Teilen. Darüber läufst du wie über jedes Array.

Einen Ergebnis-Text baust du mit += Stück für Stück zusammen. Bei vielen Teilen ist ein StringBuilder besser: append(...) hängt an, toString() liefert am Ende den fertigen String.

public class Main {
    public static void main(String[] args) {
        String sentence = "Java is fun";
        String[] words = sentence.split(" ");
        System.out.println(words.length + " words");

        String initials = "";
        for (String word : words) {
            initials += word.charAt(0);
        }
        System.out.println(initials);

        StringBuilder sb = new StringBuilder();
        for (int i = words.length - 1; i >= 0; i--) {
            sb.append(words[i]);
            if (i > 0) {
                sb.append(" ");
            }
        }
        System.out.println(sb.toString());
    }
}

Typische Fehler

  • Strings mit == vergleichen

    == prüft, ob zwei Variablen auf dasselbe Objekt zeigen, nicht ob die Buchstaben gleich sind. Bei eingelesenen oder zusammengesetzten Texten ist das oft false:

    String a = "Java";
String b = "Ja";
b += "va";
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

    Texte immer mit equals vergleichen. Nur einzelne char vergleichst du mit ==.

  • Ergebnis nicht gespeichert

    name.toUpperCase(); allein ändert nichts, weil Strings unveränderlich sind. Das Ergebnis musst du speichern: name = name.toUpperCase();.

  • length, length() oder size()?

    Beim Array ist es numbers.length ohne Klammern, beim String text.length() mit Klammern. Verwechselst du es, meldet der Compiler cannot find symbol.

  • Ende von substring

    substring(0, 3) liefert die Zeichen 0, 1 und 2, das Ende gehört nicht dazu. Liegt eine Position hinter dem Text, bricht das Programm mit StringIndexOutOfBoundsException ab. Das passiert auch bei charAt(0) auf einem leeren String.

  • char und String verwechseln

    'a' ist ein char, "a" ein String. Zwei char addiert ergeben eine Zahl: 'a' + 'b' ist 195. Erst wenn ein String beteiligt ist, wird angehängt: "" + 'a' + 'b' ist "ab".