Datentyp String

Ein String ist eine Zeichenkette, d. h. eine Sammlung von Zeichen (Datentyp char), die die Laufzeitumgebung geordnet im Speicher ablegt. Der Datentyp String hat als Wertebereich die Menge aller Zeichenketten. Strings werden in Anführungs­zeichen gesetzt; Beispiele für Strings sind "abba", "Hallo Fritz!", "@%#&$", "x" sowie auch "". Die Länge eines Strings ist die Anzahl der Zeichen, aus denen er besteht. So hat beispielsweise der String "abba" die Länge 4. Der leere String "" hat die Länge 0, da er 0 Zeichen enthält. Die einzelnen Zeichen eines Strings der Länge n werden von 0 bis n-1 nummeriert.

Das folgende Programmstück zeigt die Deklaration einer Variablen vom Typ String gefolgt von einer Wertzuweisung und anschließender Ausgabe des Strings.

 String s;
 s = "Hallo!";
 System.out.println(s);

Strings sind in Java Objekte

Der Datentyp String ist in Java kein einfacher Datentyp wie etwa int oder double oder boolean. Eine Variable vom Typ String enthält nicht den String selbst, sondern sie enthält einen Verweis auf ein Objekt vom Typ String. Dies ist deswegen nötig, weil Strings unter­schiedliche Längen annehmen können. Streng genommen wird in Java zwischen String-Konstanten und String-Objekten unterschieden. Dies ist in höchstem Maße verwirrend, weil man einem String nicht ansehen kann, ob er eine String-Konstante oder ein String-Objekt ist. Meist funktioniert aber alles wie erwartet ... wichtig ist nur, dass man Strings immer mit der Methode equals vergleicht. Bei der Vereinbarung von Strings ist darauf zu achten, dass die Datentypbezeichnung String groß geschrieben wird - wie alle in Java vereinbarten Klassen.

Wichtige Methoden für die Arbeit mit Strings

String-Länge und Test auf Leerstring

Die Länge eines Strings (die Anzahl der Zeichen) kann mit der Methode length() bestimmt werden. Um herauszufinden, ob der String keine Zeichen hat, lässt sich neben length() == 0 auch die Methode isEmpty() nutzen.

 String s = "";
 
 System.out.println( s.length() );     // 0 
 System.out.println( s.isEmpty() );    // true 
 
 s = " ";
 System.out.println( s.length() );     // 1 
 System.out.println( s.isEmpty() );    // false 
 
 String s = "Informatik";
 int k = s.length();                   // k erhält den Wert 10

Nach enthaltenen Zeichen und Zeichenfolgen suchen

Die Methode contains(CharString) testet, ob ein Teilstring (engl. substring) in der Zeichenkette vorkommt, und liefert true, wenn das der Fall ist. Zu beachten ist hier - wie bei allen String-Operationen - dass in Java zwischen Groß- und Kleinschreibung unterschieden wird. (CharSequence ist unter anderem die gemeinsame Schnittstelle von String, StringBuilder und StringBuffer.)

 if ( s.contains( "Licht" ) )   // Wenn im String s das Wort "Licht" vorkommt ...
   ...

Mit der Methode contains() kann allerdings nicht nach einem einzelnen Zeichen gesucht werden, da sie nicht mit einem char überladen ist. Zur Suche nach einem einzelnen Zeichen kann die Methode indexOf() verwendet werden: Die Methode liefert die Fundstelle eines Zeichens beziehungsweise Teilstrings. Findet indexOf() nichts, liefert sie –1.

 String s = "Alan Turing"; 
 int index1 = s.indexOf( 'n' );                // 3 
 int index2 = s.indexOf( 'n', index1 + 1 );    // 9

Die Belegung von index1 ist 3, da an der Position 3 das erste Mal ein »n« vorkommt. Die zweite Methode indexOf() sucht mit dem zweiten Ausdruck index1 + 1 ab der Stelle 4 weiter. Das Resultat ist 9.

Wie contains() unterscheidet die Suche zwischen Groß- und Kleinschreibung. Die Zeichen in einem String sind wie Array-Elemente ab 0 durchnummeriert. Ist der Index kleiner 0, so wird dies ignoriert und automatisch auf 0 gesetzt.

Vergleichen von Strings

Um Strings zu vergleichen, gibt es viele Möglichkeiten und Optionen. Zunächst sind da equals() für absolute Übereinstimmung und equalsIgnoreCase() für einen Vergleich, der unabhängig von der Groß-/Kleinschreibung ist. Ob ein String mit einem Wort beginnt oder endet, sagen startsWith() und endsWith(). Zum Vergleichen von Teilen gibt es regionMatches(), eine Methode, die auch unabhängig von der Groß-/Kleinschreibung arbeiten kann.

equals()

Als Erstes gibt es die aus der Klasse Object geerbte und in der Klasse String überschriebene Methode equals(). Die Methode gibt true zurück, falls die Strings gleich lang sind und Zeichen für Zeichen übereinstimmen.

Hinweis: Während die allermeisten Skript-Sprachen Zeichenkettenvergleiche mit == erlauben (oder z. B. auch Pascal mit =), ist die Semantik für Java immer eindeutig: Der Vergleich mit == ist nur dann wahr, wenn die beiden Referenzen gleich sind, also zwei String-Objekte identisch sind; die Gleichheit reicht nicht aus.

 String s = "Passwort"; 
 System.out.println( s == "Passwort" );         // false
 System.out.println( s.equals( "Passwort" ) );  // true 
 System.out.println( "Passwort".equals( s ) );  // true

equalsIgnoreCase()

Mit equalsIgnoreCase() bietet Java eine zu equals() analoge Methode an, um Zeichenketten ohne Beachtung der Groß-/Kleinschreibung zu vergleichen.

Lexikografische Vergleiche mit Größer/kleiner-Relation

Wie equals() und equalsIgnoreCase() vergleichen auch die Methoden compareTo(String) und compareToIgnoreCase(String) den aktuellen String mit einem anderen String. Nur ist der Rückgabewert von compareTo() kein boolean, sondern ein int. Das Ergebnis signalisiert, ob das Argument lexikografisch kleiner oder größer als das String-Objekt ist beziehungsweise mit diesem übereinstimmt. Das ist zum Beispiel in einer Sortierfunktion wichtig. Der Sortieralgorithmus muss beim Vergleich zweier Strings wissen, wie sie einzusortieren sind.

 System.out.println( "Justus".compareTo( "Bob" )    > 0 );   // true
 System.out.println( "Justus".compareTo( "Justus" ) == 0 );  // true
 System.out.println( "Justus".compareTo( "Peter" )  < 0 );   // true

Teile und Zeichen eines Strings extrahieren

Die vielleicht wichtigste Methode der Klasse String ist charAt(int index). Diese Methode liefert das entsprechende Zeichen an einer Stelle, die »Index« genannt wird. Dies bietet eine Möglichkeit, die Zeichen eines Strings (zusammen mit der Methode length()) zu durchlaufen. Ist der Index kleiner null oder größer beziehungsweise gleich der Anzahl der Zeichen im String, so löst die Methode eine StringIndexOutOfBoundsException mit der Fehlerstelle aus.

Beispiel: Liefere das erste und letzte Zeichen im String s:

 String s = "Ich bin nicht dick! Ich bin nur zu dick angezogen."; 
 char first = s.charAt( 0 );                 // 'I' 
 char last  = s.charAt( s.length() – 1 );    // '.'

Soll ein Teilstring aus der Zeichenkette erfragt werden, sollte die Methode substring() verwendet. Sie existiert in zwei Varianten – beide liefern ein neues String-Objekt zurück, das dem gewünschten Ausschnitt des Originals entspricht.

Beispiel: substring(int) liefert eine Teilzeichenkette ab einem Index bis zum Ende. Das Ergebnis ist ein neues String-Objekt.

 String s1 = "Ich denke, also bin ich."; 
 //  Position            11 
 String s2 = s1.substring( 11 );     // also bin ich

Der Index von substring(int) gibt die Startposition (null-basiert) an, ab der Zeichen in die neue Teilzeichenkette kopiert werden. substring(int) liefert den Teil von diesem Zeichen bis zum Ende des ursprünglichen Strings – es ergibt s.substring(0) gleich s.

Soll die Teilzeichenkette genauer spezifizieren, so nutzen wir die zweite Variante, substring(int,int). Ihre Argumente geben den Anfang und das Ende des gewünschten Ausschnitts an:

Beispiel: Schneide einen Teil des Strings aus.

 String traene = "Ich verlor eine Träne im tiefen Ozean, ..."; 
 //               0               16   21
 System.out.println( traene.substring( 16, 21 ) ); // Träne

Während die Startposition inklusiv ist, ist die Endposition exklusiv. Das heißt, bei der Endposition gehört das Zeichen nicht mehr zur Teilzeichenkette.

Die Methode substring(int) ist nichts anderes als eine Spezialisierung von substring(int, int), denn die erste Variante mit dem Startindex lässt sich auch als s.substring(beginIndex, s.length()) schreiben.

Zeichenfolgen als Array aus dem String extrahieren

Während charAt() nur ein Zeichen liefert, kopiert getChars() mehrere Zeichen aus einem angegebenen Bereich des Strings in ein übergebenes Feld.

 String s = "Blockflöte"; 
 char[] chars = new char[ 5 ]; 
 
 s.getChars( 5, 9, chars, 0 ); 
 System.out.println( new String(chars) );  // flöte

s.getChars() kopiert ab Position 5 aus dem String s 5 Zeichen in die Elemente des Arrays chars. Das erste Zeichen aus dem Ausschnitt steht dann in chars[0].

Die Methode getChars() muss natürlich wieder testen, ob die gegebenen Argumente im grünen Bereich liegen, das heißt, ob der Startwert nicht < 0 ist und ob der Endwert nicht über die Größe des Strings hinausgeht. Passt das nicht, löst die Methode eine StringIndexOutOfBoundsException aus. Liegt zudem der Startwert hinter dem Endwert, gibt es ebenfalls eine StringIndexOutOfBoundsException, die anzeigt, wie groß die Differenz der Positionen ist. Am besten ist es, die Endposition aus der Startposition zu berechnen, wie es im obigen Beispiel geschehen ist. Passen alle Zeichen in das Feld, kopiert die Implementierung der Methode getChars() mittels System.arraycopy() die Zeichen aus dem internen Array des String-Objekts in das von uns angegebene Ziel.

Möchten wir den kompletten Inhalt eines Strings als ein Array von Zeichen haben, so können wir die Methode toCharArray() verwenden. Intern arbeitet die Methode auch mit getChars(). Als Ziel-Array legt toCharArray() nur ein neues Array an, das wir dann zurückbekommen.