Kapitel 4 Der Umgang mit Zeichenketten

Ohne Unterschied macht Gleichheit keinen Spaß.
– Dieter Hildebrandt

4.1 Strings und deren Anwendung 

Ein String ist eine Sammlung von Zeichen, die im Speicher geordnet abgelegt werden. Die Zeichen sind einem Zeichensatz entnommen, der in Java dem Unicode-Standard entspricht. In Java ist eine Symbiose zwischen String als Objekt und String als eingebautem Datentyp vorgenommen worden. Die Sprache ermöglicht zwar die direkte Konstruktion von String-Objekten aus String-Literalen (Zeichenketten in doppelten Anführungszeichen) und die Konkatenation (Aneinanderreihung von Strings mit +) von mehreren Strings, aber alle weiteren Operationen sind als Methoden in den Klassen String , StringBuffer und StringBuilder realisiert. Der Unterschied zwischen StringBuffer und StringBuilder ist lediglich, dass StringBuffer gegen nebenläufige Operationen sicher ist, während StringBuilder das nicht ist.

Die Klasse String repräsentiert Zeichenketten, die sich nicht ändern; sie heißen immutable-Objekte. Mit Objekten vom Typ String lässt sich suchen und vergleichen, aber es können keine Zeichen im String verändert werden. Es gibt einige Methoden, die scheinbar Veränderungen an Strings vornehmen, aber sie erzeugen in Wahrheit neue String-Objekte, die die veränderten Zeichenreihen repräsentieren. So entsteht beim Aneinanderhängen zweier String-Objekte als Ergebnis ein drittes String-Objekt für die zusammengefügte Zeichenreihe. Die Klassen StringBuffer und StringBuilder repräsentieren im Gegensatz dazu dynamische, beliebig änderbare Zeichenreihen.

Die Klassen String und StringBuffer abstrahieren die Funktionsweise und die Speicherung von Zeichenketten. Sie entsprechen der idealen Umsetzung von objektorientierter Programmierung. Die Daten werden gekapselt (die tatsächliche Zeichenkette ist in der Klasse als privates Feld gegen Zugriffe von außen gesichert), und selbst die Länge ist ein Attribut der Klasse.

4.1.1 String-Objekte für konstante Zeichenketten 

Damit wir Zeichenketten nutzen können, muss ein Objekt der Klasse String oder StringBuffer erzeugt worden sein. Nutzen wir Literale, so müssen wir String-Objekte nicht von Hand mit new erzeugen, denn für jedes Zeichenketten-Literal im Programm wird (bei Bedarf) automatisch ein entsprechendes String-Objekt erzeugt. Dies geschieht für jede konstante Zeichenkette höchstens einmal, egal wie oft sie im Programmverlauf benutzt wird. (Denken wir hier wieder an das Beispiel println().) Neben den String-Literalen, die uns Strings erzeugen, können wir auch direkt einen Konstruktor der Klasse String – von denen es neun gibt – aufrufen. Als String-Literal wird eine konstante Zeichenkette betrachtet. So ergeben die beiden folgenden Zeilen die Referenz auf ein String-Objekt:

String str = "Wer ist Rudolf Wijbrand Kesselaar?";
String str = new String( "Wer ist Rudolf Wijbrand Kesselaar?" );

Die zweite Lösung erzeugt unnötigerweise ein zusätzliches String-Objekt, denn das Literal ist ja schon ein String-Objekt.

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. Es wird selten benötigt, da String-Objekte unveränderbar (immutable) sind.

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

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

String( byte bytes[] ) Erzeugt ein neues Objekt aus dem Bytefeld. 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 Bytefelds.

String( byte bytes[], String ) 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 ) throws UnsupportedEncodingException Erzeugt einen neuen String mit einem Teil des Byte-Arrays mithilfe einer speziellen Zeichenkodierung.

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

String( StringBuilder builder ) Erzeugt den String aus einem StringBuilder.

String( int codePoints[], int offset, int count) Neu in Java Java 5 sind die Codepoints, die Zeichen über int kodieren.

Leerer String, Leer-String oder Null-String

Durch

String str = "";

oder

String str = new String();

werden String-Objekte erzeugt, die keine Zeichen enthalten. Diesen String nennen wir dann leeren String, Leer-String oder Null-String. Der letzte Begriff ist leider etwas unglücklich und führt oft zur Verwechslung mit Folgendem:

String s = null;
System.out.println( s );              // null

Hier bekommen wir keinen leeren String und bei der Benutzung im Methodenaufruf, etwa s.length(), eine NullPointerException.

Strings einer gegebenen Länge erzeugen

An einigen Stellen in den Bibliotheken gibt es noch Nachholbedarf – das gilt besonders für die Klasse String. Zum Beispiel gibt es keine Funktion, die eine Zeichenkette einer vorgegebenen Länge aus einem einzelnen Zeichen erzeugt. Selbst in einfachsten Basic-Dialekten gibt es solche Funktionen. In Java müssen wir diese selbst entwickeln.

Zuerst ist zu fragen, ob die Zeichenkette als String oder als StringBuffer/StringBuilder bereitgestellt werden soll? In der Regel wird dieses Objekt ein String sein. Auch ohne Bibliotheksfunktionen lässt sich mit dem Plus-Operator eine Zeichenkette in einer Schleife zusammensetzen. Das ist sicherlich die erste Idee:

String s = "";

for ( int i = 0; i < len; ++i )
  s += c;

Hier ist len die Länge des Ergebnis-Strings und c das Zeichen.

In einer kritischen Geschwindigkeitsbetrachtung fällt das dauernde Erzeugen von temporären StringBuffer-Objekten auf. Die Lösung ist langsam. Anders können wir dies lösen, indem wir ein char-Feld der passenden Größe erzeugen, dies mit den Zeichen füllen und anschließend einmalig in einen String konvertieren. Anstelle des Zeichenfelds wählen wir besser einen StringBuffer.

4.1.2 String-Länge 

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 diese so implementiert, dass die Anzahl der Zeichen im String (die Länge des Strings) zurückgegeben wird.

4.1.3 Gut, dass wir verglichen haben 

Um Strings zu vergleichen, existieren eine Menge Möglichkeiten und Optionen. Oft wollen wir einen konstanten String mit einer Benutzereingabe vergleichen. Hier gibt es die aus der Klasse Object geerbte, aber in der Klasse String überschriebene Methode equals(). Die Methode gibt true zurück, falls die Strings Zeichen für Zeichen übereinstimmen. Groß- und Kleinschreibung werden dabei unterschieden. Mit equalsIgnoreCase() werden zwei Zeichenketten verglichen, ohne dass auf die Groß-/Kleinschreibung geachtet wird.

String str = "REISEPASS";
boolean result1 = str.  equals  ( "Reisepass" );             // false
boolean result2 = str.  equalsIgnoreCase  ( "ReISePaSs" );   // true

Sortierung mit der Größer/Kleiner-Relation

Wie equals() und equalsIgnoreCase() vergleichen auch die Methoden compareTo(String) und compareToIgnoreCase(String) zwei Strings. equals() aus String überschreibt sie die Methode equals() aus Object, so dass der Parametertyp auch Object ist. Der Argumenttyp beim Aufruf kann natürlich völlig anders sein, doch Gleichheit stellt equals()nur dann fest, wenn das Argument auch vom Typ String ist. (Bei beliebigen Objekten wird nicht automatisch die Methode toString() aufgerufen.) Selbst Vergleiche mit einem inhaltsgleichen StringBuffer-Objekt ergeben immer false – ein StringBuffer ist kein String. Der Rückgabewert von compareTo() ist auch 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.

s.  compareTo  ( "Bob" )     > 0
   //"Justus" ist lexikographisch größer als "Bob"
s.  compareTo  ( "Justus" ) == 0
s.  compareTo  ( "Peter" )   < 0

Der von compareTo() vorgenommene Vergleich basiert nur auf der internen numerischen Kodierung der Unicode-Zeichen. Die Vergleichsfunktion berücksichtigt nicht die landestypischen Besonderheiten, etwa die übliche Behandlung der deutschen Umlaute. Dafür müssten wir Collator-Klassen nutzen, die später vorgestellt werden.

compareToIgnoreCase() ist vergleichbar mit equalsIgnoreCase(), bei der die Groß-/Kleinschreibung keine Rolle spielt. Bei Sun wird dies intern mit einem Comparator implementiert, der zwei beliebige Objekte – für Zeichenketten natürlich vom Typ String – in eine Reihenfolge bringt.

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. "http://java-tutor.de".startsWith("http") ergibt true. Eine ähnliche Funktion gibt es für Suffixe: endsWith(). Sie überprüft, ob ein String mit einer Zeichenfolge am Ende übereinstimmt.

String filename  = "Echolallie.gif";
boolean issesGif = filename.  endsWith  ( ".gif" );    // true

String-Teile vergleichen

Eine Erweiterung der Ganz-oder-gar-nicht-Vergleichsfunktionen bietet die Methode regionMatches(), mit der Teile einer Zeichenkette mit Teilen einer anderen verglichen werden können. 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 Groß-/Kleinschreibung durchführen. Der Rückgabewert ist wie bei equalsXXX() ein boolean.

String s = "Deutsche Kinder sind zu dick";
s.  regionMatches  ( 9, "Bewegungsarmut bei Kindern", 19, 6 );

Die Methode beginnt den Vergleich am neunten Zeichen, also bei »K« im String s und dem 19. Buchstaben in dem Vergleichsstring, 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« dann true.

s.regionMatches( true, 9, "Bewegungsarmut bei Kindern", 19, 6 );

4.1.4 String-Teile extrahieren 

Die vielleicht wichtigste Funktion 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.

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 0 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() stattfindet, ist zu überlegen, ob der String bei mehrmaligem Zugriff nicht stattdessen einmalig in ein eigenes Zeichen-Array kopiert werden sollte.

Zeichenfolgen als Array aus dem String extrahieren

Eine Erweiterung von charAt() ist getChars(), die Zeichen aus einem angegebenen Bereich in ein übergebenes Feld kopiert:

String s = "Body-Mass-Index  = " +
  "Körpergewicht (kg) / Körpergröße (m) / Körpergröße (m)";
char chars[] = new char[13];
s.  getChars  ( 18, 18 + 13, chars, 0 );

s.getChars() kopiert ab Position 18 aus dem String s 13 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 im obigen Beispiel. Passen die Werte, 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, so können wir die Methode toCharArray() verwenden. Für häufigen Zugriff auf einen String bewirkt dies eine Geschwindigkeitssteigerung. toCharArray() arbeitet intern auch mit getChars(). Als Ziel-Array wird ein neues Array Objekt angelegt, welches wir dann zurückbekommen.

char c = "0123456789ABCDEF".toCharArray()[i & 15];

Für diesen speziellen Fall wäre charAt() zwar schneller gewesen, jedoch demonstriert das Beispiel, dass wir per [] auch direkt auf die Array-Elemente eines Methodenergebnisses zugreifen können. Das ist völlig korrekt, denn toCharArray() liefert ein Array als Ergebnis.

Teile eines Strings als String

Wollen wir bei den Teilstrings keine Zeichenfelder bekommen, sondern bei dem Typ String bleiben, so greifen wir zur Methode substring(), die in zwei Varianten existiert. Sie liefern beide ein neues String-Objekt zurück, das einem Teil des Originals entspricht.

String s1 = "Die erste McDonalds Filiale öffnete 1971 in München";
String s2 = s1.  substring  ( 44 );                  // München

Der String s2 ist dann »München«. Der Index von substring() gibt die Startposition an, ab der Zeichen in die neue Teilzeichenkette kopiert werden. substring() liefert den Teil von diesem Zeichen bis zum Ende des ursprünglichen Strings.

Wollten wir die Teilzeichenkette genauer spezifizieren, so nutzen wir die zweite Variante von substring(). Ihre Parameter erwarten den Anfang und das Ende des gewünschten Ausschnitts:

String s1 = "fettleibig : adipös";
String s2 = s1.  substring  ( 4, 8 );       // leib

Wie man sieht, bezeichnet die Endposition das erste Zeichen des ursprünglichen Strings, das nicht mehr zur Teilzeichenkette dazugehören soll. Bei genauerer Betrachtung ist substring(int) nichts anderes als eine Spezialisierung von substring(int, int), denn die erste Variante mit dem Startindex lässt sich auch schreiben als:

s.substring( beginIndex, s.length() );

Selbstverständlich kommen nun diverse Indexüberprüfungen hinzu, die wir von match Region() kennen. Eine StringIndexOutOfBoundsException meldet fehlerhafte Positionsangaben. Stimmen diese, konstruiert ein spezieller String-Konstruktor ein neues String-Objekt als Auszug des Originals.

Strings rechtsbündig setzen

Falls wir immer ein fixes Zeichen verwenden und die String-Länge in einem festen Bereich bleibt, so ist eine andere Möglichkeit noch viel eleganter (aber nicht unbedingt schneller). Sie arbeitet mit der substring()-Methode. Wir schneiden aus einem großen String mit festen Zeichen einfach einen String mit der benötigten Länge heraus. Damit lässt sich auch flott eine Zeile formulieren, die einen Text mit so vielen Leerzeichen füllt, dass dieser rechtsbündig ist:

text = "                  ".substring( text.length() );

Die Anzahl der Zeichen muss natürlich mit der Zeichenkettenlänge harmonisieren.

4.1.5 Suchen und Ersetzen 

Um die erste Position eines Zeichens im String zu finden, verwenden wir die indexOf()-Methode. Als Argument lässt sich unter anderem ein Zeichen oder ein String vorgeben, der gesucht wird.

String str = "Ernest Gräfenberg";
int index = str.indexOf( ’e’ );                     // 3

Im Beispiel ist index gleich 3, da an der Position 3 das erste Mal ein »e« vorkommt. Die Zeichen in einem String werden wie Array-Elemente ab 0 durchnummeriert. Falls das gesuchte Zeichen in dem String nicht vorkommt, gibt die Methode indexOf() als Ergebnis –1 zurück.

index = str.  indexOf  ( ’e’, index + 1 );              // 11

Mit dem Ausdruck index+1 als Argument der Methode wird in unserem Beispiel ab der Stelle 4 weitergesucht. Das Resultat der Methode ist dann 11. Ist der Index kleiner 0, so wird dies ignoriert und automatisch auf 0 gesetzt.

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

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

String str = "Gary Schubach";
int index  = str.  lastIndexOf  ( ’a’ );                 // 10

Hier ist index gleich 10. Genauso wie bei indexOf() existiert eine überladene Version, die rückwärts ab einer bestimmten Stelle nach dem nächsten Vorkommen von »a« sucht. Wir schreiben:

index = str.lastIndexOf( ’a’, index – 1 );

Nun ist der Index 1.² 

Es gibt noch eine weitere Version von indexOf() und lastIndexOf(), die nach einem Teilstring (engl. substring) sucht. Die Versionen erlauben ebenfalls einen zweiten Parameter, der den Startindex bestimmt.

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

Die nächste Suchposition wird ausgehend von der alten Finderposition errechnet. Das Ergebnis ist 57, da dort zum zweiten Mal das Wort »es« auftaucht.

Das Ideom s.indexOf(t) > –1 ist seit Java 5 nicht mehr nötig, um zu testen, ob ein Teilstring t im String s hier, da es seit dem die Methode contains() gibt.

Zeichen ersetzen

Da String-Objekte unveränderlich sind, kann eine Veränderungsfunktion nur einen neuen String mit den Veränderungen zurückgeben. Die replace()-Methode ist ein Beispiel für diese Vorgehensweise.

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

Das String-Objekt mit dem Namen s1 wird selbst nicht verändert, nur ein neues String-Objekt mit dem Inhalt »Hunululu« wird erzeugt und von replace() zurückgegeben.

Die replace()-Methode betrachtet dafür intern eine Kopie des Zeichenfelds und geht dann Schritt für Schritt das Feld ab und führt die Ersetzungen aus. Die replace()-Methode ersetzt dabei alle Zeichen. Eine Variante, die nur das erste Zeichen ersetzt, müssen wir uns selbst schreiben.

Suchen und ersetzen

In Java 5 wurde die Methode replace() eingeführt, die in einem String alle auftretenden Strings sucht und durch einen anderen Sting ersetzt.

String s = "’Tag, Karl.’ ’Wie geht’s, Karl?’ ’Gut, Karl.’ ’Kahl, Karl?’ 
’Ja, Karl, ganz kahl.’";
System.out.println( s.replace(".", "!") );

Hier ersetzen wir alle Punkte durch Ausrufezeichen, so dass das Ergebnis ist:

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

Suchen und ersetzten mit regulären Ausdrücken

Die Funktionen replaceAll() und replaceFirst() suchen in Zeichenketten mit Hilfe von regulären Ausdrücken und nehmen Ersetzungen vor; replaceFirst() ersetzt, wie es der Name schon sagt, nur das erste Auftreten.

String s = "Schnecken erschrecken, wenn Schnecken an Schnecken schlecken, " +
        "weil zum Schrecken vieler Schnecken, Schnecken nicht schmecken.";
System.out.println( s.replaceAll("Schnecke", "Katze") );

Für ganz allgemeine Ersetzungsaufgaben eignen sich replaceAll() und replaceFirst() nicht; hier ist die replace()-Funktion passend. Da der Suchstring immer ein regulärer Ausdruck ist, können Sonderzeichen auftauchen, die eine besondere Rolle spielen. So müssen zum Beispiel Dollar oder Punkt mit \ ausmaskiert werden. Sollen in unserer Karl-Zeichenfolge wieder alle Punkte durch Ausrufezeichen ersetzen werden, so würde s.replaceAll(".", "!") nicht zum Erfolg führen, sondern nur zu einer Zeichenkette

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

Der Punkt steht in regulären Ausdrücken für beliebige Zeichen. Erst s.replaceAll("\\.", "!") liefert das gewünschte Ergebnis.

4.1.6 Veränderte Strings liefern 

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 vorgenommen, sondern die Methode liefert eine Referenz auf ein neues String-Objekt mit verändertem Inhalt zurück.

Anhängen an Strings

Eine weitere Methode erlaubt das Anhängen von Teilen an einen String. Wir haben dies schon öfters mit dem Plus-Operator realisiert. Die Methode von String dazu heißt concat(String). Wir werden später sehen, dass die StringBuffer-Klasse dies noch weiter treibt und eine Methode append() mit der gleichen Funktionalität anbietet, die Methode aber für unterschiedliche Typen überladen ist. Das steckt auch hinter dem Plus-Operator. Der Compiler wandelt dies automatisch in eine Kette von append()-Aufrufen um.

String s1 = "Das aktuelle Datum ist: ";
String s2 = new Date().toString();
String s3 = s1.  concat  ( s2 ); 
// Das aktuelle Datum ist: Tue Jun 03 14:46:41 CEST 2003

Die concat()-Methode arbeitet relativ zügig und effizienter als der Plus-Operator, der einen temporären String-Puffer anlegt. Doch mit dem Plus-Operator ist es hübscher anzusehen. (Aber wie das so ist: Sieht nett aus, aber ...)

String s3 = "Das aktuelle Datum ist: " + new Date().toString();

Es geht sogar noch kürzer, denn der Plus-Operator ruft automatisch toString() bei Objekten auf:

String s3 = "Das aktuelle Datum ist: " + new Date();

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

Groß-/Kleinschreibung

Die Klasse Character definiert einige statische Methoden, um einzelne Zeichen in Groß-/Kleinbuchstaben umzuwandeln. Die Schleife, die das für jedes Zeichen macht, 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 kein 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 »SPASS 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.

String s1 = "Spaß in der Naßzelle.";
String s2 = s1.  toLowerCase().toUpperCase()  ;      // 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 könnte die neue Zeichenkette nicht mehr in den Speicherbereich passen. 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. Wir gehen in einem eigenen Kapitel auf Sprachumgebungen und die Klasse Locale ein. Die parameterlosen Methoden wählen die Sprachumgebung gemäß den Länder-Einstellungen des Betriebssystems:

public String toLowerCase() {
  return toLowerCase( Locale.getDefault() );
}

Ähnliches steht bei toUpperCase().

Leerzeichen entfernen

In einer Benutzereingabe oder Konfigurationsdatei stehen nicht selten vor oder hinter dem wichtigen Teil eines Texts Leerzeichen. Vor der Bearbeitung sollten sie entfernt werden. Die String-Klasse bietet dazu trim() an. Diese Methode entfernt Leer- und ähnliche Füllzeichen am Anfang und Ende eines Strings. Andere Trendy-Sprachen wie Visual Basic bieten dazu noch trim()-Funktionen an, die nur die Leerzeichen vorher oder nachher verwerfen. Die Java-Bibliothek bietet das leider nicht.³ 

String s = " 1234    ".  trim()  ;            // s = "1234"
int i = Integer.parseInt( s );            // i = 1234

Die Konvertierungsfunktion selbst schneidet keine Leerzeichen ab und würde einen Parserfehler melden. Die Helden der Java-Bibliothek haben allerdings bei Float.parseFloat() und Double.parseDouble() anders gedacht. Hier wird die Zeichenkette vorher schlank getrimmt. parseInt() unterstützt verschiedene Zahlensysteme, nicht jedoch Gleitkommazahlen. Auch die Verwandtschaft zwischen den Methoden valueOf() und parseXXX() ist in der Klasse Integer gerade andersherum beschrieben als bei Double und Float.

4.1.7 Unterschiedliche Typen in Zeichenketten konvertieren 

Bevor ein Datentyp auf dem Bildschirm ausgegeben werden kann, zum Drucker geschickt oder in einer ASCII-Datei gespeichert wird, muss er in einen String konvertiert werden. Wenn wir etwa die Zahl 7 ohne Umwandlung ausgeben würden, hätten wir keine 7 auf dem Bildschirm, sondern einen Pieps.

Die String-Repräsentation eines primitiven Werts oder eines Objekts kennt die überladene Methode valueOf(). Sie konvertiert einen Datentyp in einen String. Alle valueOf()-Methoden sind statisch.

String s1 = String.  valueOf  ( 10 );             // "10"
String s2 = String.  valueOf  ( Math.PI );        // "3.141592653589793"
String s3 = String.  valueOf  ( 1 < 2 );          // "true"
String s4 = String.  valueOf  ( new Date() );     
// "Tue Jun 03 14:40:38 CEST 2003"

Sehen wir uns einige Implementierungen an:

public static String valueOf( boolean b ) {
  return b ? "true" : "false";
}

Die Methode gibt einfach das passende Literal zurück, unabhängig von der Landessprache. Hier ist die Funktionalität direkt ausprogrammiert. Die Klasse Boolean, die Wrapper-Klasse für den primitiven Datentyp boolean, ist nicht im Spiel, obwohl es ordentlicher wäre. Genauso bei einem Zeichenfeld:

public static String valueOf( char data[] ) {
  return new String(data);
}

Wir können auch selbst den Konstruktor nutzen, der aus dem Zeichenfeld ein String-Objekt konstruiert.

valueOf() wälzt die Arbeit bei allen anderen primitiven Datentypen an die zuständige Wrapper-Klasse ab, so auch bei einer Ganzzahl:

public static String valueOf( int i ) {
  return Integer.toString( i, 10 );
}

Dies ist wichtig einzusehen, denn es ist nicht Aufgabe der Klasse String, sich darum zu kümmern, wie eine Zahl in eine Zeichenfolge umgewandelt wird.

Es bleibt abschließend die Frage nach valueOf(Object). Hier kann weder eine Wrapper-Klasse helfen noch kann String selbst etwas machen. Hier ist jedes Objekt gefragt:

public static String valueOf( Object obj ) {
  return (obj == null) ? "null" : obj.toString();
}

Und ein Objekt kann helfen, da jedes eine toString()-Methode besitzt. Dynamisch gebunden (dazu später mehr) landet der Aufruf in der jeweiligen Klasse des Objekts, sofern diese die Methode toString() überschreibt.

¹  Mit 31 Zeichen gehört dieser Methodenname schon zu den längsten. Übertroffen wird aber noch um 5 Zeichen von TransformerFactoryConfigurationError.

²   Diese Ungenauigkeit ist unter der Bug-ID 4075078 bei Sun gemeldet und immer noch in Bearbeitung. Eine rückwärts kompatible Lösung gibt es aber nicht.

³   Wieder ein Hinweis, dass Visual Basic einfach die bessere Sprache ist ...