5.5    Die Klasse String und ihre Methoden 

Die Entwickler von Java haben eine Symbiose zwischen String als Klasse und dem String als eingebauten Datentyp gebildet. Die Sonderbehandlung gegenüber anderen Objekten ist an zwei Punkten abzulesen:

• Die Sprache ermöglicht die direkte Konstruktion von String-Objekten aus String-Literalen (Zeichenketten in doppelten Anführungszeichen), wie "Hallo Welt".

• Die Konkatenation (Aneinanderreihung von Strings mit +, wie in "Hallo" + " " + "Welt") von mehreren Strings ist erlaubt, aber Plus ist für keinen anderen Objekttyp erlaubt. Es lassen sich zum Beispiel nicht zwei Point-Objekte addieren. Mit dem Plus auf String-Objekten ist also ein besonderer Operator auf der Klasse String definiert; benutzerdefinierte überladene Operatoren sind in Java nicht möglich.

Die Klasse String bietet genau eine Konstante CASE_INSENSITIVE_ORDER vom Typ Comparator<String>, ein paar Konstruktoren, statische Methoden sowie Objektmethoden – diese schauen wir uns im Folgenden an.

 

5.5.1    String-Literale als String-Objekte für konstante Zeichenketten 

Damit wir Zeichenketten nutzen können, muss ein Objekt der Klasse String vorliegen. Das Schöne ist, dass alles in doppelten Anführungszeichen schon automatisch ein String-Objekt ist. Das bedeutet auch, dass hinter dem String-Literal gleich ein Punkt für den Methodenaufruf stehen kann.

Nur Zeichenfolgen in doppelten Anführungszeichen sind String-Literale und somit schon gleich vorkonstruierte Objekte. Das gilt für StringBuilder/StringBuffer nicht – sie müssen von Hand mit new erzeugt werden. Nutzen wir String-Literale, so sollten wir ausdrücklich davon absehen, String-Objekte mit new zu erzeugen: Ein s = new String("String") ist unsinnig, s = "String" ist korrekt.

 

5.5.2    Konkatenation mit + 

Mehrere Beispiele haben schon gezeigt, dass Strings mit + konkateniert werden können.

int    age    = 39;

double height = 1.83;

String s = "Alter: " + age + ", Größe: " + height;

System.out.println( s );      // Alter: 39, Größe: 1.83

 

5.5.3    String-Länge und Test auf Leer-String 

String-Objekte verwalten intern die Zeichenreihe, die sie repräsentieren, und bieten eine Vielzahl von Methoden, um die Eigenschaften des Objekts preiszugeben. Eine Methode haben wir schon benutzt: length(). Für String-Objekte ist sie so implementiert, dass sie die Anzahl der Zeichen im String (die Länge des Strings) zurückgibt. Um herauszufinden, ob der String keine Zeichen hat, lässt sich neben length() == 0 auch die Methode isEmpty() nutzen. In Java 11 ist die Methode isBlank() hinzugekommen, die testet, ob der String leer ist oder nur aus Weißraum besteht. Weißraum ist jedes Zeichen, bei dem Character.isWhitespace(int) wahr anzeigt.

Tabelle 5.7    Ergebnisse der Methoden »length()«, »isEmpty()« und »isBlank()«

Eine praktische Hilfsmethode: isNullOrEmpty(String)

Während das .NET-Framework etwa die statische Member-Funktion IsNullOrEmpty(String) anbietet, die testet, ob die übergebene Referenz null oder die Zeichenkette leer ist, muss das in Java getrennt getestet werden. Hier ist eine eigene statische Utility-Methode praktisch:

Listing 5.3    src/main/java/com/tutego/insel/string/LengthAndEmptyDemo.java, Ausschnitt

/**

 * Checks if a String is {@code null} or empty ({@code ""}).

 *

 * <pre>

 * StringUtils.isNullOrEmpty(null) == true

 * StringUtils.isNullOrEmpty(&quot;&quot;) == true

 * StringUtils.isNullOrEmpty(&quot; &quot;) == false

 * StringUtils.isNullOrEmpty(&quot;bob&quot;) == false

 * StringUtils.isNullOrEmpty(&quot; bob &quot;) == false

 * </pre>

 *

 * @param str The String to check, may be {@code null}.

 * @return {@code true} if the String is empty or {@code null}, {@code false}

 * otherwise.

 */

public static boolean isNullOrEmpty( String str ) {

  return str == null || str.isEmpty();

}

Ob der String nur aus Weißraum besteht, testet die Methode nicht.

 

5.5.4    Zugriff auf ein bestimmtes Zeichen mit charAt(int) 

Die vielleicht wichtigste Methode der Klasse String ist charAt(int index).[ 133 ](Der Parametertyp int verrät, dass Strings nicht größer als Integer.MAX_VALUE sein können, also nicht länger als 2.147.483.647 Zeichen. ) 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 bzw. gleich der Anzahl der Zeichen im String, so löst die Methode eine StringIndexOutOfBoundsException[ 134 ](Mit 31 Zeichen gehört dieser Klassenname schon zu den längsten. Übertroffen wird er aber noch um fünf Zeichen von TransformerFactoryConfigurationError. Im Spring-Paket (einer Sammlung von Bibliotheken für die Java EE-Entwicklung) gibt es aber JdbcUpdateAffectedIncorrectNumberOfRowsException – auch nicht von schlechten Eltern. ) mit der Fehlerstelle aus.

String s = "Ich bin nicht dick! Ich habe nur weiche Formen.";

char first = s.charAt( 0 );                          // 'I'

char last  = s.charAt( s.length() - 1 );             // '.'

Wir müssen bedenken, dass die Zählung wieder bei null beginnt. Daher müssen wir von der Länge des Strings eine Stelle abziehen. Da der Vergleich auf den korrekten Bereich bei jedem Zugriff auf charAt(int) stattfindet, ist zu überlegen, ob der String bei mehrmaligem Zugriff nicht stattdessen einmalig in ein eigenes Zeichen-Array kopiert werden sollte.

 

5.5.5    Nach enthaltenen Zeichen und Zeichenfolgen suchen 

Die Objektmethode contains(CharSequence) testet, ob ein Teil-String (engl. substring) in der Zeichenkette vorkommt, und liefert true, wenn das der Fall ist. Groß-/Kleinschreibung ist relevant. Im nächsten Programm wollen wir testen, ob eine E-Mail mögliche Spam-Wörter enthält:

Listing 5.4    src/main/java/com/tutego/insel/string/EmailSpamChecker.java, Ausschnitt

public class EMailSpamChecker {



  public static void main( String[] args ) {

    String email1 = "Hallo Chris, alle fit im Schritt?";

    System.out.println( containsSpam( email1 ) );  // false

    String email2 = "Kaufe Viagra! Noch billiga und macht noch härta!";

    System.out.println( containsSpam( email2 ) );  // true

  }



  public static boolean containsSpam( String text ) {

    return text.contains( "Viagra" ) || text.contains( "Ding-Dong-Verlängerung" );

  }

}

Fundstelle mit indexOf(…) zurückgeben

Die Methode contains(…) ist nicht mit einem char überladen, kann also nicht nach einem einzelnen Zeichen suchen, es sei denn, der String bestünde nur aus einem Zeichen. Dazu ist indexOf(…) in der Lage: Die Methode liefert die Fundstelle eines Zeichens bzw. Teil-Strings. Findet indexOf(…) nichts, liefert sie –1.

String s = "Ernest Gräfenberg";

int index1 = s.indexOf( 'e' );                     // 3

int index2 = s.indexOf( 'e', index1 + 1 );         // 11

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

if ( "\b\t\n\f\r\"\\".indexOf(c) >= 0 ) {

  ...

}

Die indexOf(…)-Methode ist nicht nur mit char parametrisiert, sondern auch mit String[ 135 ](Der Parametertyp String erlaubt natürlich nur Objekte vom Typ String, und Unterklassen von String gibt es nicht. Allerdings gibt es andere Klassen in Java, die Zeichenfolgen beschreiben, etwa StringBuilder oder StringBuffer. Diese Typen unterstützt die indexOf(…)-Methode nicht. Das ist schade, denn indexOf(…) hätte statt String durchaus einen allgemeineren Typ CharSequence erwarten können, um den String sowie StringBuilder/StringBuffer zu implementieren. (Zu dieser Schnittstelle folgt mehr in Abschnitt 1.7, »AdoptOpenJDK installieren«). ), um nach ganzen Zeichenfolgen zu suchen und die Startposition zurückzugeben.

String str = "In Deutschland gibt es immer noch ein Ruhrgebiet, " +

             "obwohl es diese Krankheit schon lange nicht mehr geben soll.";

String s = "es";

int index = str.indexOf( s, str.indexOf(s) + 1 );       // 57

Vom Ende an suchen

Genauso wie am Anfang gesucht werden kann, ist es auch möglich, am Ende zu beginnen.

String str = "May the Force be with you.";

int index  = str.lastIndexOf( 'o' );                 // 23

index = str.lastIndexOf( 'o', index - 1 );          // 9

Die Parameter der char-orientierten Methoden indexOf(…) und lastIndexOf(…) sind alle vom Typ int und nicht, wie man spontan erwarten könnte, vom Typ char und int. Das zu suchende Zeichen wird als erstes int-Argument übergeben. Die Umwandlung des char in ein int nimmt der Java-Compiler automatisch vor, sodass dies nicht weiter auffällt. Bedauerlicherweise kann es dadurch aber zu Verwechslungen bei der Reihenfolge der Argumente kommen: Bei s.indexOf(start, c) wird der erste Parameter start als Zeichen interpretiert und das gewünschte Zeichen c als Startposition der Suche.

Anzahl der Teil-Strings einer Zeichenkette *

Bisher bietet die Java-Bibliothek keine direkte Methode, um die Anzahl der Teil-Strings einer Zeichenkette herauszufinden. Eine solche Methode ist jedoch schnell geschrieben:

Listing 5.5    src/main/java/com/tutego/insel/string/CountMatches.java, Ausschnitt

public class CountMatches {



  public static int frequency( String source, String part ) {

    if ( source == null || source.isEmpty() || part == null || part.isEmpty() )

      return 0;



    int count = 0;



    for ( int pos = 0; (pos = source.indexOf( part, pos )) != -1; count++ )

      pos += part.length();



    return count;

  }



  public static void main( String[] args ) {

    System.out.println( frequency( "schlingelschlangel", "sch" ) );  // 2

    System.out.println( frequency( "schlingelschlangel", "ing" ) );  // 1

    System.out.println( frequency( "schlingelschlangel", "" ) );     // 0

  }

}

Die gewählte Implementierung liefert die Anzahl nicht überlappender Teil-Strings, würde also beim Aufruf frequency("aaaa", "aa") das Ergebnis 2 liefern, denn mit pos += part.length() geht die Implementierung immer so viele Schritte weiter nach rechts, wie der Teil-String lang ist. Je nach Interpretation der Aufgabe – und anderen Algorithmus – wäre auch 3 eine erlaubte Rückgabe, aber dann müsste die Schleife immer nur eine Position nach rechts gehen.

 

5.5.6    Das Hangman-Spiel 

Die Methoden, die wir bisher schon kennengelernt haben, lösen geschätzte 90 % aller Aufgaben in der täglichen Programmierpraxis:

• int charAt(int)

• int length()

• boolean equals(Object)

• boolean contains(CharSequence)

• int indexOf(char), int indexOf(String)

Genau diese Methoden wollen wir für ein kleines Spiel nutzen, das berühmte Hangman-Spiel. Hierbei geht es darum, alle Buchstaben eines Wortes zu raten. Am Anfang ist jeder Buchstabe durch einen Unterstrich unkenntlich gemacht. Der Benutzer fängt an zu raten und füllt nach und nach die einzelnen Platzhalter aus. Gelingt es dem Spieler nicht, nach einer festen Anzahl von Runden das Wort zu erraten, hat er verloren.

Listing 5.6    src/main/java/com/tutego/insel/string/Hangman1.java, Ausschnitt

public static void main( String[] args ) {

  String hangmanWord = "alligatoralley";

  String usedChars = "";

 

  String guessedWord = "";

  for ( int i = 0; i < hangmanWord.length(); i++ )

    guessedWord += "_";

 

  for ( int guesses = 0; ; guesses++ ) {

    if ( guesses == 10 ) {

      System.out.printf( "Nach 10 Versuchen ist jetzt Schluss. Sorry! " +

                         "Apropos, das Wort war '%s'.", hangmanWord );

      break;

    }

 

    System.out.printf( "Runde %d. Bisher geraten: %s." +

                       "Was wählst du für ein Zeichen?%n", guesses, guessedWord );

    char guessedChar = new java.util.Scanner( System.in ).next().charAt( 0 );

 

    if ( usedChars.indexOf( guessedChar ) >= 0 )

      System.out.printf( "%c hast du schon mal getippt!%n", guessedChar );

    else { // Zeichen wurde noch nicht benutzt 

      usedChars += guessedChar;

      if ( hangmanWord.indexOf( guessedChar ) >= 0 ) {

        guessedWord = "";

        for ( int i = 0; i < hangmanWord.length(); i++ )

          guessedWord += usedChars.indexOf( hangmanWord.charAt( i ) ) >= 0 ?

                           hangmanWord.charAt( i ) : "_";

 

        if ( guessedWord.contains( "_" ) )

          System.out.printf( "Gut geraten, '%s' gibt es im Wort. " +

                             "Aber es fehlt noch was!%n", guessedChar );

        else {

          System.out.printf( "Gratulation, du hast das Wort '%s' erraten!",

                             hangmanWord );

          break;

        }

      }

      else { // hangmanWord.indexOf( c ) == -1 

        System.out.printf( "Pech gehabt, %c kommt im Wort nicht vor!%n",

                           guessedChar );

      }

    }

  }

}

Das Spiel startet mit einer Ausgabe wie:

Runde 0. Bisher geraten: ______________. Was wählst du für ein Zeichen?

Wir geben einen Buchstaben ein, etwa »e«, drücken dann (¢), und das Programm reagiert:

e

Gut geraten, 'e' gibt es im Wort. Aber es fehlt noch was!

Runde 1. Bisher geraten: ____________e_. Was wählst du für ein Zeichen?

a

Gut geraten, 'a' gibt es im Wort. Aber es fehlt noch was!

Runde 2. Bisher geraten: a____a___a__e_. Was wählst du für ein Zeichen?

Dann geht es weiter bis zum Ende des Spiels.

 

5.5.7    Gut, dass wir verglichen haben 

Um Strings zu vergleichen, gibt es viele Möglichkeiten und Optionen:

• Die Methode equals(…) der Klasse String achtet auf absolute Übereinstimmung.

• Die Methode equalsIgnoreCase(…) der Klasse String ist für einen Vergleich zu haben, der unabhängig von der Groß-/Kleinschreibung ist.

• Die switch-Anweisung ermöglicht den Vergleich von String-Objekten mit einer Liste von Sprungzielen. Intern führt equals(…) den Vergleich durch.

• Ob ein String mit einem Wort beginnt oder endet, sagen die String-Methoden startsWith(…) und endsWith(…).

• Zum Vergleichen von Teilen gibt es die String-Methode regionMatches(…), eine Methode, die auch unabhängig von der Groß-/Kleinschreibung arbeiten kann.

• Ist eine Übereinstimmung mit einem regulären Ausdruck gewünscht, helfen die Methode matches(…) von String sowie die speziellen Klassen Pattern und Matcher, die speziell für reguläre Ausdrücke sind.

Die Methode equals(…)

Die Klasse String überschreibt die aus der Klasse Object geerbte Methode equals(…), um zwei Strings vergleichen zu können. Die Methode gibt true zurück, falls die Strings gleich lang sind und Zeichen für Zeichen übereinstimmen.

String input = javax.swing.JOptionPane.showInputDialog( "Passwort" );

System.out.println( input == "heinzelmann" );              //    (1)

System.out.println( input.equals( "heinzelmann" ) );       //    (2.1)

System.out.println( "heinzelmann".equals( input ) );       //    (2.2)

Grundsätzlich sind Variante (2.1) und (2.2) gleich, da equals(…) symmetrisch ist. Doch gibt es einen Vorteil bei (2.2), denn da kann input auch null sein, und es gibt nicht wie bei (2.1) eine NullPointerException.

System.out.println( "\t".equals( "\n" ) );                // false

System.out.println( "\t".equals( "\t " ) );               // false

System.out.println( "\u0000".equals( "\u0000\u0000" ) );  // false

Die Methode equalsIgnoreCase(…)

equals(…) beachtet beim Vergleich die Groß- und Kleinschreibung. Mit equalsIgnoreCase(…) bietet die Java-Bibliothek eine zusätzliche Methode, um Zeichenketten ohne Beachtung der Groß-/Kleinschreibung zu vergleichen; der Test findet Zeichen für Zeichen statt.

String str = "REISEPASS";

boolean result1 = str.equals( "Reisepass" );             // false

boolean result2 = str.equalsIgnoreCase( "ReISePaSs" );   // true

Lexikografische Vergleiche mit Größer/Kleiner-Relation

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

System.out.println( "Justus".compareTo( "Bob" )    > 0 );

System.out.println( "Justus".compareTo( "Justus" ) == 0 );

System.out.println( "Justus".compareTo( "Peter" )  < 0 );

Der von compareTo(String) vorgenommene Vergleich basiert nur auf der internen numerischen Kodierung der Unicode-Zeichen. Dabei berücksichtigt compareTo(…) nicht die landestypischen Besonderheiten, etwa die übliche Behandlung der deutschen Umlaute. Dafür müssten wir Collator-Klassen nutzen, die in »Java SE 9 Standard-Bibliothek« vorgestellt werden.

compareToIgnoreCase(…) ist mit equalsIgnoreCase(…) vergleichbar, bei der die Groß-/Kleinschreibung keine Rolle spielt.

Endet der String mit …, beginnt er mit …?

Interessiert uns, ob der String mit einer bestimmten Zeichenfolge beginnt (wir wollen dies Präfix nennen), so rufen wir die startsWith(…)-Methode auf. Eine ähnliche Methode gibt es für Suffixe: endsWith(…). Sie überprüft, ob ein String mit einer Zeichenfolge endet.

String   filename = "die besten stellungen (im schach).txt";

boolean  isTxt    = filename.endsWith( ".txt" );                // true

String   email    = "Sehr geehrte Frau Müller,\ndanke für Ihr Angebot.";

boolean  isMale   = email.startsWith( "Sehr geehrter Herr" );   // false

String-Teile mit regionMatches(…) vergleichen *

Eine Erweiterung der Ganz-oder-gar-nicht-Vergleichsmethoden bietet regionMatches(…), die Teile einer Zeichenkette mit Teilen einer anderen vergleicht. Nimmt das erste Argument von regionMatches(…) den Wahrheitswert true an, dann spielt die Groß-/Kleinschreibung keine Rolle – damit lässt sich dann auch ein startsWith(…) und endsWith(…) mit Vergleichen unabhängig von der Groß-/Kleinschreibung durchführen. Der Rückgabewert ist wie bei equalsXXX(…) ein boolean.

String  s = "Deutsche Kinder sind zu dick";

// Position: 0        9

boolean b = s.regionMatches( 9, "Bewegungsarmut bei Kindern", 19, 6 );

// Position:                     0                  19

Die Methode beginnt den Vergleich am neunten Zeichen, also bei »K« im String s, und beim 19. Buchstaben in dem Vergleichs-String, ebenfalls ein »K«. Dabei beginnt die Zählung der Zeichen wieder bei 0. Ab diesen beiden Positionen werden sechs Zeichen verglichen. Im Beispiel ergibt der Vergleich von »Kinder« und »Kinder« true.

String  s = "Deutsche KINDER sind zu dick";

boolean b = s.regionMatches( true, 9, "Bewegungsarmut bei kindern", 19, 6 );

 

5.5.8    String-Teile extrahieren 

Die wichtigste Methode der Klasse String, nämlich charAt(int index), haben wir schon mehrfach benutzt. Sie ist aber nicht die einzige Methode, um auf gewisse Teile eines Strings zuzugreifen.

Teile eines Strings als String mit substring(…) erfragen

Wollen wir einen Teil-String aus der Zeichenkette erfragen, so greifen wir zur Methode substring(…). Sie existiert in zwei Varianten – beide liefern ein neues String-Objekt zurück, das dem gewünschten Ausschnitt des Originals entspricht.

String s1 = "Welche Sprache spricht man in der Sauna? Schwyzerdütsch";

// Position: 0                                        41

String s2 = s1.substring( 41 );                  // Schwyzerdütsch

Der Index von substring(int) gibt die Startposition (nullbasiert) 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 gilt somit, dass s.substring(0) für jeden beliebigen String s ungleich null gleich s ist.

Wollen wir 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.

String tear = "'Jede Träne kitzelt auch die Wange.'";

//             0     6    11

System.out.println( tear.substring( 6, 11 ) ); // Träne

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.

public static String firstToUpper( String string ){

  if ( string.isEmpty() ) return "";

  return string.substring( 0, 1 ).toUpperCase().concat( string.substring( 1 ) );

}

return Character.toUpperCase( string.charAt( 0 ) ) + string.substring( 1 );

Selbstverständlich kommen nun diverse Indexüberprüfungen hinzu – eine StringIndexOutOfBoundsException[ 136 ](Die API-Dokumentation spricht von einer IndexOutOfBoundsException, doch StringIndexOutOfBoundsException ist eine Unterklasse davon. ) meldet fehlerhafte Positionsangaben wie bei charAt(int).

String vor/nach einem Trenn-String *

Die String-Klasse bietet keine einfache Bibliotheksmethode für den Fall an, dass ein Trennzeichen gegeben und ein Teil-String vor oder nach diesem Trennzeichen gefragt ist.[ 137 ](Selbst XPath bietet mit substring-before() und substring-after() solche Funktionen. Und Apache Commons Lang (http://commons.apache.org/lang) bildet sie auch nach in der Klasse org.apache.commons.lang.StringUtils. Mit regulären Ausdrücken oder mit split(…) von String lässt sich so etwas theoretisch lösen, aber elegant ist der Code auch nicht. ) Dabei wäre eine solche Methode praktisch, etwa bei Dateien, bei denen der Punkt den Dateinamen vom Suffix trennt. Wir wollen zwei statische Utility-Methoden, substringBefore(String string, String delimiter) und substringAfter(String string, String delimiter), schreiben, die genau diese Aufgabe übernehmen. Angewendet sehen sie dann so aus (wir ignorieren für einen Moment, dass der Dateiname selbst auch einen Punkt enthalten kann):

• substringBefore( "index.html", "." ) liefert "index".

• substringAfter( "index.html", "." ) liefert "html".

Die Implementierung der Methoden ist einfach: Im ersten Schritt suchen die Methoden mit indexOf(…) nach dem Trenner. Anschließend liefern sie mit substring(…) den Teil-String vor bzw. hinter diesem gefundenen Trenn-String. Noch einige Vereinbarungen: Der Trenner ist kein Teil der Rückgabe. Und taucht das Trennzeichen nicht im String auf, ist die Rückgabe von substringBefore(…) der gesamte String und bei substringAfter(…) der Leer-String. String und Trenner dürfen nicht null sein. Wenn dem so ist, folgt eine NullPointerException und zeigt so den Programmierfehler an. Ausprogrammiert sehen die beiden Methoden so aus:

Listing 5.7    src/main/java/com/tutego/insel/string/StringUtils.java, Ausschnitt

public class StringUtils {



  /**

   * Returns the substring before the first occurrence of a delimiter.

   * The delimiter is not part of the result.

   *

   * @param string    String to get a substring from.

   * @param delimiter String to search for.

   * @return          Substring before the first occurrence of the delimiter.

   */

  public static String substringBefore( String string, String delimiter ) {

    int pos = string.indexOf( delimiter );



    return pos >= 0 ? string.substring( 0, pos ) : string;

  }



  /**

   * Returns the substring after the first occurrence of a delimiter. 

   * The delimiter is not part of the result.

   *

   * @param string    String to get a substring from.

   * @param delimiter String to search for.

   * @return          Substring after the first occurrence of the delimiter.

   */

  public static String substringAfter( String string, String delimiter ) {

    int pos = string.indexOf( delimiter );



    return pos >= 0 ? string.substring( pos + delimiter.length() ) : "";

  }

}

Zur Übung sei es den Lesern überlassen, noch die zwei Methoden substringBeforeLast(…) und substringAfterLast(…) zu realisieren, die statt indexOf(…) die Methode lastIndexOf(…) einsetzen (mit den beiden Methoden kann auch der Dateiname selbst einen Punkt enthalten). Frage: Lässt sich in der Implementierung einfach indexOf(…) durch lastIndexOf(…) ersetzen, und war es das dann schon?

Mit getChars(…) Zeichenfolgen als Array aus dem String extrahieren *

Während charAt(int) nur ein Zeichen vom String liefert, kopiert getChars(int srcBegin, int srcEnd, char[] dest, int dstBegin) mehrere Zeichen aus einem angegebenen Bereich des Strings in ein übergebenes Array.

String s = "Blasiussegen";

char[] chars = new char[ 5 ];

int srcBegin = 7;

s.getChars( srcBegin, srcBegin + 5, chars, 0 );

System.out.println( new String(chars) );  // segen

Die Methode getChars(…) muss natürlich wieder testen, ob die angegebenen 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 Array, 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.

String string = "Herr, schmeiß Java vom Himmel!";

for ( char c : string.toCharArray() )

  System.out.println( c );

Weitere Möglichkeiten zur Zerlegung

Es gibt zwei weitere Möglichkeiten, aus einem String gewisse Teile zu extrahieren. Zum einen erlaubt split(…) das Zerlegen einer Zeichenkette mithilfe eines regulären Ausdrucks. Dann gibt es noch seit Java 11 die Methode lines(), die einen Strom von Zeilen liefert, getrennt durch den Zeilenumbruch.

String text = " Masterpiece Tweeter\t  \n   Dolomiten";

text.lines().forEach( line -> System.out.println( line.trim() ) );

 

5.5.9    Strings anhängen, zusammenfügen, Groß-/Kleinschreibung und Weißraum 

Obwohl String-Objekte selbst unveränderlich sind, bietet die Klasse String Methoden an, die aus einer Zeichenkette Teile herausnehmen oder ihr Teile hinzufügen. Diese Änderungen werden natürlich nicht am String-Objekt selbst vorgenommen, auf dem die Methode aufgerufen wird, sondern die Methode liefert eine Referenz auf ein neues String-Objekt mit verändertem Inhalt zurück.

Anhängen an Strings

Um an einen String einen weiteren String anzuhängen, gibt es zwei naheliegende Möglichkeiten:

• mit der String-Methode concat(String)

• mit dem Plus-Operator. Das ist im Grunde flexibler, da Nicht-Strings vorher in Strings konvertiert werden.

Wir werden später sehen, dass es die StringBuilder/StringBuffer-Klassen noch weiter treiben und überladene append(…)-Methoden für unterschiedliche Datentypen anbieten.

String s1 = "Die Uhrzeit ist: ";

String s2 = LocalTime.now().toString();

String s3 = s1.concat( s2 ); // Die Uhrzeit ist: 20:08:39.267490200

String s4 = "Die Uhrzeit ist: " + LocalTime.now().toString();

String s5 = "Die Uhrzeit ist: " + LocalTime.now();

concat(String) legt ein internes Array an, kopiert die beiden Zeichenreihen per getChars(…) hinein und liefert mit einem String-Konstruktor die resultierende Zeichenkette.

Mehrere Strings zusammenfügen

Zwei überladene Klassenmethoden join(…) können mehrere Zeichenketten zusammenfügen und zwischen den Gliedern einen Trenn-String setzen. Die Methoden unterscheiden sich in der Parameterliste: Einmal kommen die Glieder direkt über ein Vararg und einmal über ein Iterable:

• static String join(CharSequence delimiter, CharSequence... elements)

• static String join(CharSequence delimiter, Iterable<? extends CharSequence>
  
  elements)

Die Argumente müssen Zeichenfolgen sein und können nicht etwa allgemeine Objekte sein, die automatisch in Strings konvertiert werden. Auch null dürfen die Glieder nicht sein.

String s = String.join( " ", "Geht", "ein", "Mullah", "in", "die", "Bar." );

Der Trenn-String darf nicht null sein, kann aber durchaus leer sein.

In StringBuilder/StringBuffer gibt es keine vergleichbare Methode, wohl aber eine kleine Klasse StringJoiner, die auch die eigentliche Arbeit von join(…) vollzieht.

Groß-/Kleinschreibung

Die Klasse Character deklariert einige statische Methoden, die einzelne Zeichen in Groß-/Kleinbuchstaben umwandeln. Die Schleife, die das für jedes Zeichen übernimmt, können wir uns sparen, denn dazu gibt es die Methoden toUpperCase(…) und toLowerCase(…) in der Klasse String. Interessant ist an beiden Methoden, dass sie einige sprachabhängige Feinheiten beachten. So zum Beispiel, dass es im Deutschen nicht wirklich ein großes »ß« gibt, denn »ß« wird zu »SS«. Gammelige Textverarbeitungen bekommen das manchmal nicht auf die Reihe, und im Inhaltsverzeichnis steht dann so etwas wie »SPAß IN DER NAßZELLE«. Aber bei möglichen Missverständnissen müsste »ß« auch zu »SZ« werden, vergleiche »SPASZ IN MASZEN« mit »SPASS IN MASSEN« (ein ähnliches Beispiel steht im Duden). Diese Umwandlung ist aber nur von Klein nach Groß von Bedeutung. Für beide Konvertierungsrichtungen gibt es jedoch im Türkischen Spezialfälle, bei denen die Zuordnung zwischen Groß- und Kleinbuchstaben von der Festlegung in anderen Sprachen abweicht. Und seit dem 29. Juni 2017 ist das große Eszett Bestandteil der amtlichen deutschen Rechtschreibung; es liegt im Unicode-Alphabet an Position U+1E9E. Warten wir ab, ob der Konverteralgorithmus umgestellt wird.

String s1 = "Spaß in der Naßzelle.";

String s2 = s1.toLowerCase().toUpperCase();

System.out.println( s2 );     // SPASS IN DER NASSZELLE.

System.out.println( s2.length() - s1.length() ); // 2

Das Beispiel dient zugleich als Warnung, dass sich im Fall von »ß« die Länge der Zeichenkette vergrößert. Das kann zu Problemen führen, wenn vorher Speicherplatz bereitgestellt wurde. Dann passt die neue Zeichenkette möglicherweise nicht mehr in den Speicherbereich. Arbeiten wir nur mit String-Objekten, haben wir dieses Problem glücklicherweise nicht. Aber berechnen wir etwa für einen Texteditor die Darstellungsbreite einer Zeichenkette in Pixel auf diese Weise, dann sind Fehler vorprogrammiert.

Um länderspezifische Besonderheiten zu berücksichtigen, lassen sich die toXXXCase(…)-Methoden zusätzlich mit einem Locale-Objekt füttern (Locale-Objekte repräsentieren eine sprachliche Region).

System.out.println( "TITANIK".toLowerCase()  );                      // titanik

System.out.println( "TITANIK".toLowerCase( new Locale( "tr" ) )  );  // tıtanık

public String toLowerCase() {

  return toLowerCase( Locale.getDefault() );

}

Weißraum entfernen

In einer Benutzereingabe oder Konfigurationsdatei steht nicht selten vor oder hinter dem wichtigen Teil eines Textes Weißraum wie Leerzeichen oder Tabulatoren. Vor der Bearbeitung sollten sie entfernt werden. Die String-Klasse bietet dazu trim() und seit Java 11 strip(), stripLeading() und stripTrailing() an. Der Unterschied:

Tabelle 5.8    Unterschiede zwischen »trim()« und »stripXXX()«

Alle vier genannten Methoden entfernen keinen Weißraum inmitten des Strings.

String s = " \tSprich zu der Hand.\n  \t ";

System.out.println( "'" + s.trim() + "'" ); // 'Sprich zu der Hand.'

boolean isBlank = "".equals( s.trim() );

boolean isBlank = s.trim().isEmpty();

 

5.5.10    Gesucht, gefunden, ersetzt 

Da String-Objekte unveränderlich sind, kann eine Veränderungsmethode nur einen neuen String mit den Veränderungen zurückgeben. Es gibt in Java vier Methoden, die suchen und ersetzen:

final class java.lang.String

implements Serializable, Comparable<String>, CharSequence

• String replace(char oldChar, char newChar): Ersetzt alle Auftreten des Zeichens oldChar durch newChar.

• String replace(CharSequence target, CharSequence replacement): Ersetzt eine Zeichenkette durch eine andere Zeichenkette.

• String replaceAll(String regex, String replacement): Ersetzt alle Strings, die durch einen regulären Ausdruck beschrieben werden.

• String replaceFirst(String regex, String replacement): Ersetzt den ersten String, den ein regulärer Ausdruck beschreibt.

Ersetzen ohne reguläre Ausdrücke

Die replace(char, char)-Methode ersetzt einzelne Zeichen.

String s1 = "Honolulu";

String s2 = s1.replace( 'o', 'u' );          // s2 = "Hunululu"

Gibt es etwas zu ersetzen, erzeugt replace(…) intern ein neues char-Array, führt die Ersetzungen durch und konvertiert das interne Zeichen-Array in ein String-Objekt, das die Rückgabe ist. Gab es nichts zu ersetzen, bekommen wir das gleiche String-Objekt zurück, das die Anfrage stellte. Die replace(…)-Methode ersetzt immer alle Zeichen. Eine Variante, die nur das erste Zeichen ersetzt, müssen wir uns selbst schreiben.

Eine zweite überladene Variante, replace(CharSequence, CharSequence), sucht nach allen auftretenden Zeichenfolgen und ersetzt sie durch eine andere Zeichenfolge. Der Ersetzungs-String kann auch leer sein, und so werden die Zeichen im Ergebnis gelöscht.

String s = "Schnecken erschrecken, wenn Schnecken an Schnecken schlecken, " +

           "weil zum Schrecken vieler Schnecken Schnecken nicht schmecken.";

System.out.println( s.replace("Schnecke", "Katze") );

Suchen und ersetzen mit regulären Ausdrücken *

Die Methoden replaceAll(…) und replaceFirst(…) suchen in Zeichenketten mithilfe von regulären Ausdrücken und nehmen Ersetzungen vor. replaceFirst(…) ersetzt, wie der Name schon sagt, nur das erste Auftreten.

String s = "Alles  fit im   Schritt?";

System.out.println( s.replaceAll( " +", " " ) );   // Alles fit im Schritt?

System.out.println( s.replaceFirst( " +", " " ) ); // Alles fit im   Schritt?

Weil der Such-String immer ein regulärer Ausdruck ist und Sonderzeichen wie ».« oder »+« eine Sonderrolle einnehmen, eignen sich replaceAll(…) und replaceFirst(…) nicht direkt für allgemeine Ersetzungsaufgaben; hier ist die replace(…)-Methode passender und auch schneller.

String s = "'Tag, Karl.' 'Wie geht's, Karl?' 'Gut, Karl.' 'Kahl, Karl?' " +

           "'Ja, Karl, ganz  kahl.'";

System.out.println( s.replace( ".", "!" ) );

'Tag, Karl!' 'Wie geht's, Karl?' 'Gut, Karl!' 'Kahl, Karl?' 'Ja, Karl, ganz kahl!'

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Der Punkt steht in regulären Ausdrücken für beliebige Zeichen. Erst wenn ein Backslash (\) den Punkt ausmaskiert (wegen des Sonderstatus des Backslashs als Escape-Sequenz in Strings muss auch dieses Zeichen selbst ausmaskiert werden), liefert die Anweisung wie in s.replaceAll("\\.", "!") das gewünschte Ergebnis. Die statische Methode Pattern.quote(String) maskiert die Pattern-Sonderzeichen für uns aus, sodass auch s.replaceAll(Pattern.quote("."), "!") gut funktioniert. In »Java SE 9 Standard-Bibliothek« gehe ich noch intensiver auf reguläre Ausdrücke ein. Auch die API-Dokumentation http://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/regex/Pattern.html gibt neben einer vollständigen Dokumentation kleine Beispiele.

 

5.5.11    String-Objekte mit Konstruktoren und aus Wiederholungen erzeugen * 

Die String-Klasse hat diverse Methoden, die neue String-Objekte aufbauen, insbesondere weil String-Objekte immutable sind. Zu den Methoden zählen substring(…), join(…), format(…).

Neue String-Objekte mit Konstruktoren aufbauen

Liegt die Zeichenkette nicht als String-Literal vor, lassen sich mit den unterschiedlichen Konstruktoren der String-Klasse neue String-Objekte aufbauen. Die meisten Konstruktoren sind für Spezialfälle gedacht und kommen in normalen Java-Programmen nicht vor:

final class java.lang.String

implements CharSequence, Comparable<String>, Serializable

• String()
  
  Erzeugt ein neues Objekt ohne Zeichen (den leeren String "").

• String(String string)
  
  Erzeugt ein neues Objekt mit einer Kopie von string. Der Konstruktor ist im Prinzip unnötig, da String-Objekte unveränderbar (immutable) sind.

• String(char[] value)
  
  Erzeugt ein neues Objekt und kopiert die im value vorhandenen Zeichen in das neue String-Objekt.

• String(char[] value, int offset, int length)
  
  Erzeugt wie String(char[]) einen String aus einem Ausschnitt eines char-Arrays. Der verwendete Ausschnitt beginnt bei dem Index offset und umfasst length Zeichen.

• String(byte[] bytes)
  
  Erzeugt ein neues Objekt aus dem Array bytes. Das byte-Array enthält keine Unicode-Zeichen, sondern eine Folge von Bytes, die nach der Standardkodierung der jeweiligen Plattform in Zeichen umgewandelt werden.

• String(byte[] bytes, int offset, int length)
  
  Erzeugt wie String(byte[]) einen String aus einem Ausschnitt eines Byte-Arrays.

• String(byte[] bytes, String charsetName) throws UnsupportedEncodingException
  
  Erzeugt einen neuen String von einem Byte-Array mithilfe einer speziellen Zeichenkodierung, die die Umwandlung von Bytes in Unicode-Zeichen festlegt.

• String(byte[] bytes, int offset, int length, String charset)
  
  throws UnsupportedEncodingException
  
  Erzeugt einen neuen String mit einem Teil des Byte-Arrays mithilfe einer speziellen Zeichenkodierung.

• String(StringBuffer buffer)

• String(StringBuilder builder)
  
  Erzeugt aus einem veränderlichen StringBuffer/StringBuilder-Objekt ein unveränderliches String-Objekt, das dieselbe Zeichenreihe repräsentiert.

• String(int[] codePoints, int offset, int count)
  
  Erzeugt ein String-Objekt mit Unicode-Codepoints, die Zeichen über int kodieren.

Die Konstruktoren sind im Speziellen nur dann nötig, wenn aus einer Fremdrepräsentation wie einem StringBuilder, StringBuffer, char[] oder byte[] oder Teilen von ihnen ein String-Objekt aufgebaut werden soll.

public static String generateStringWithLength( int len, char fill ) {

  char[] chars = new char[ len ];

  Arrays.fill( chars, fill );

  return new String( chars );

}

String a1 = "iPad", a2 = "Paid";

char[] a1chars = a1.toCharArray();

char[] a2chars = a2.toCharArray();

Arrays.sort( a1chars );

Arrays.sort( a2chars );

boolean isAnangram = new String(a1chars).equalsIgnoreCase(new String(a2chars));

System.out.println( isAnangram );       // true

Über den Konstruktoraufruf new String(String)

Ein Konstruktor führt leicht zur Verwirrung, und zwar der Konstruktor, der einen anderen String annimmt. So ergeben die beiden folgenden Zeilen die Referenz auf ein String-Objekt:

String rudi = "There is no spoon";

String rudi = new String( "There is no spoon" );

Die zweite Lösung erzeugt unnötigerweise ein zusätzliches String-Objekt, denn das Literal ist ja schon ein vollwertiges String-Objekt. Der Konstruktor ist im Grunde unnötig.

Strings im Konstantenpool

Die JVM erzeugt für jedes Zeichenketten-Literal automatisch ein entsprechendes String-Objekt. Das geschieht für jede konstante Zeichenkette höchstens einmal, egal wie oft die JVM sie im Programmverlauf benutzt und welche Klassen den String referenzieren. Dieses String-Objekt »lebt« in einem Bereich, der Konstantenpool genannt wird.[ 138 ](Die Java-Bibliothek implementiert hier das Entwurfsmuster Fliegengewicht (Flyweight-Pattern) der Gang of Four. )

System.out.println( "tutego" );

int len = "tutego".length();

Bei konstanten Werten führt der Compiler Optimierungen durch, etwa in der Art, dass er konstante Ausdrücke gleich berechnet. Nicht nur setzt er für Ausdrücke wie 1 + 2 das Ergebnis 3 ein, auch aufgebrochene konstante String-Teile, die mit Plus konkateniert werden, fügt der Compiler zu einer Zeichenkette zusammen.

String s =

 "Operating systems are like underwear-nobody really wants to look at them.";

String s = "Operating systems are like underwear" +

           '-' + "nobody really wants to look at them.";

Leerer String, Leer-String oder null-String

Die Anweisungen

String s = "";

und

String s = new String();

referenzieren in beiden Fällen String-Objekte, die keine Zeichen enthalten. Die zweite Schreibweise erzeugt aber ein neues String-Objekt, während im ersten Fall das String-Literal im Konstantenpool liegt.

Einen String ohne Zeichen nennen wir leeren String, Leer-String oder Null-String. Der letzte Begriff ist leider etwas unglücklich gewählt, sodass wir ihn im Buch nicht nutzen, denn der Begriff Null-String kann leicht mit dem Begriff null-Referenz verwechselt werden. Doch während Zugriffe auf einen Null-String unproblematisch sind, führen Dereferenzierungen auf der null-Referenz unweigerlich zu einer NullPointerException:

String s = null;

System.out.println( s );         // Ausgabe: null

s.length();                      //  NullPointerException

printXXX(null) führt zu der Konsolenausgabe »null« und zu keiner Ausnahme, da es eine Fallunterscheidung in printXXX(Object) und printXXX(String) gibt, die die null-Referenz als Sonderfall betrachtet.[ 140 ](In der Implementierung von PrintStream: public void print( String s ) { if ( s == null ) s = "null"; write( s ); }) Der Zugriff auf s über s.length() führt dagegen zur unbeliebten NullPointerException.

Strings aus Wiederholungen generieren

In Java 11 ist eine Objektmethode repeat(int count) eingezogen, die einen gegebenen String vervielfacht.

String s = "tu";

System.out.println( s.repeat( 3 ) );    // tututu

int    n = 3;

String t = new String( new char[ n ] ).replace( "\0", s );

System.out.println( t );                // tututu