Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 11 - Strings

## 11.2 Methoden der Klasse String

- 11.2 Methoden der Klasse String
  - 11.2.1 Konstruktoren
  - 11.2.2 Zeichenextraktion
  - 11.2.3 Die Länge der Zeichenkette
  - 11.2.4 Vergleichen von Zeichenketten
  - 11.2.5 Suchen in Zeichenketten
  - 11.2.6 Ersetzen von Zeichenketten
  - 11.2.7 Konvertierungsfunktionen

Die Klasse `String` definiert eine Vielzahl von Methoden zur Manipulation und zur Bestimmung der Eigenschaften von Zeichenketten. Da Strings und die auf ihnen definierten Operationen bei der Anwendung einer Programmiersprache ein wichtiges und für die Effizienz der Programmentwicklung kritisches Merkmal sind, sollen hier die wichtigsten String-Operationen vorgestellt werden. Weitere Methoden dieser Klasse können den Referenzhandbüchern der Java-Klassenbibliothek oder der Online-Hilfe entnommen werden.

### 11.2.1 Konstruktoren

Die Klasse `String` bietet eine Reihe von Möglichkeiten, neue Instanzen zu erzeugen. Neben der bereits in Kapitel 4 erläuterten Initialisierung mit Hilfe von Literalen besitzt die Klasse eine Reihe von Konstruktoren, die dazu verwendet werden können, `String`-Objekte explizit zu erzeugen.

    String()
| java.lang.String

Erzeugt ein leeres String-Objekt.

    String(String value)
| java.lang.String

Erzeugt einen neuen String durch Duplizierung eines bereits vorhandenen.

    String(char[] value)
| java.lang.String

Erzeugt einen neuen String aus einem vorhandenen Zeichen-Array. Dabei werden alle Elemente des Arrays in den String übernommen.

|  | Nachdem ein `String` erzeugt wurde, kann er wie jedes andere Objekt verwendet werden. Insbesondere erfolgt damit im Gegensatz zu C oder C++ das Speichermanagement vollautomatisch, ohne daß sich der Programmierer darum kümmern muß. |  |
Hinweis

### 11.2.2 Zeichenextraktion

    char charAt(int index)
      throws StringIndexOutOfBoundsException
| java.lang.String

Liefert das Zeichen an Position `index`. Dabei hat das erste Element eines Strings den Index 0 und das letzte den Index `length()-1`. Falls der String kürzer als `index + 1` Zeichen ist, wird eine Ausnahme des Typs `StringIndexOutOfBoundsException` erzeugt.

    String substring(int begin, int end)
| java.lang.String

Liefert den Teilstring, der an Position `begin` beginnt und an Position `end` endet. Wie bei allen Zugriffen über einen numerischen Index beginnt auch hier die Zählung bei 0.

|  | Ungewöhnlich bei der Verwendung dieser Methode ist die Tatsache, daß der Parameter `end` auf das erste Zeichen hinter den zu extrahierenden Teilstring verweist (siehe Abbildung 11.1). Der Rückgabewert ist also die Zeichenkette, die von Indexposition `begin` bis Indexposition `end - 1` reicht. |  |
Hinweis

Abbildung 11.1: Ein Aufruf von substring(begin, end)

Es gibt noch eine zweite Variante der Methode `substring`, die mit nur einem einzigen Parameter aufgerufen wird. Sie liefert den Teilstring von der angegebenen Position bis zum Ende des Strings.

    String trim()
| java.lang.String

Die Methode liefert den String, der entsteht, wenn auf beiden Seiten der Zeichenkette jeweils alle zusammenhängenden Leerzeichen entfernt werden. Dabei werden alle Zeichen, die einen Code kleiner gleich 32 haben, als Leerzeichen angesehen. Leider gibt es keine separaten Methoden für das rechts- oder linksbündige Entfernen von Leerzeichen, `trim` entfernt immer die Leerzeichen auf beiden Seiten. Da die Klasse `String` als `final` deklariert wurde, gibt es auch keine Möglichkeit, entsprechende Methoden nachzurüsten.

### 11.2.3 Die Länge der Zeichenkette

    int length()
| java.lang.String

Liefert die aktuelle Länge des `String`-Objekts. Ist der Rückgabewert 0, so bedeutet dies, daß der String leer ist. Wird ein Wert n größer 0 zurückgegeben, so enthält der String n Zeichen, die an den Indexpositionen 0 bis n - 1 liegen.

Das folgende Beispiel zeigt die Verwendung der Methoden `substring` und `length` und der `String`-Verkettung auf (letztere wird in Abschnitt 11.3.2 noch einmal genauer behandelt).

    001 /* Listing1101.java */
    002
    003 public class Listing1101
    004 {
    005   public static void main(String[] args)
    006   {
    007     String s1;
    008     s1 =  "Auf der Mauer";
    009     s1 += ", auf der Lauer";
    010     s1 += ", sitzt \'ne kleine Wanze";
    011     System.out.println(s1);
    012
    013     for (int i = 1; i <= 5; ++i) {
    014       s1 = s1.substring(0,s1.length()-1);
    015       System.out.println(s1);
    016     }
    017   }
    018 }
| Listing1101.java

Listing 11.1: String-Verkettung und die Methode substring

Die Ausgabe des Programmes ist:

    Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wanze
    Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wanz
    Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wan
    Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wa
    Auf der Mauer, auf der Lauer, sitzt 'ne kleine W
    Auf der Mauer, auf der Lauer, sitzt 'ne kleine

### 11.2.4 Vergleichen von Zeichenketten

    boolean equals(Object anObject)
    boolean equalsIgnoreCase(String s)

    boolean startsWith(String s)
    boolean endsWith(String s)

    int compareTo(String s)

    boolean regionMatches(
       int toffset,
       String other,
       int ooffset,
       int len
    )
| java.lang.String

`equals` liefert `true`, wenn das aktuelle String-Objekt und `anObject` gleich sind. Analog zu der gleichnamigen Methode der Klasse `Object` überprüft `equals` also nicht, ob beide Strings dasselbe Objekt referenzieren, sondern testet auf inhaltliche Gleichheit. Interessant an `equals` ist die Tatsache, daß als Parameter ein Objekt der Klasse `Object` erwartet wird. `equals` kann einen String also nicht nur mit einem anderen String vergleichen, sondern mit der String-Darstellung eines beliebigen Objekts.

Neben `equals` gibt es noch eine ähnliche Methode, `equalsIgnoreCase`, die eventuell vorhandene Unterschiede in der Groß-/Kleinschreibung beider Zeichenketten ignoriert.

`startsWith` testet, ob das String-Objekt mit der Zeichenkette `s` beginnt. Ist das der Fall, so gibt die Methode `true` zurück, andernfalls `false`. `endsWith` überprüft dagegen, ob das String-Objekt mit der Zeichenkette `s` endet. Ist das der Fall, gibt die Methode ebenfalls `true` zurück, andernfalls `false`.

Die wichtige Methode `compareTo` führt einen lexikalischen Vergleich beider Strings durch. Bei einem lexikalischen Vergleich werden die Zeichen paarweise von links nach rechts verglichen. Tritt ein Unterschied auf oder ist einer der Strings beendet, wird das Ergebnis ermittelt. Ist das aktuelle String-Objekt dabei kleiner als `s`, wird ein negativer Wert zurückgegeben. Ist es größer, wird ein positiver Wert zurückgegeben. Bei Gleichheit liefert die Methode den Rückgabewert 0.

`regionMatches` vergleicht zwei gleich lange String-Regionen, die in zwei unterschiedlichen Strings an zwei unterschiedlichen Positionen liegen können. Die Region im ersten String beginnt dabei an der Position `toffset`, die im zweiten String `other` an der Position `ooffset`. Verglichen werden `len` Zeichen. Das Ergebnis ist `true`, wenn beide Teilstrings identisch sind, andernfalls ist es `false`. Die Methode steht auch in einer Variante zur Verfügung, bei der Groß- und Kleinschreibung ignoriert werden. In diesem Fall wird als zusätzlicher Parameter an erster Stelle ein boolescher Wert `ignoreCase` übergeben.

Die Anwendung von `regionMatches` soll an folgendem Beispiel erläutert werden. Der erste Vergleich liefert `true` (siehe Abbildung 11.2), der zweite `false`:

    001 /* Listing1102.java */
    002
    003 public class Listing1102
    004 {
    005   public static void main(String[] args)
    006   {
    007     System.out.println(
    008       "Grüße aus Hamburg".regionMatches(
    009         8,
    010         "Greetings from Australia",
    011         8,
    012         2
    013       )
    014     );
    015     System.out.println(
    016       "Grüße aus Hamburg".regionMatches(
    017         6,
    018         "Greetings from Australia",
    019         15,
    020         3
    021       )
    022     );
    023   }
    024 }
| Listing1102.java

Listing 11.2: Die Methode regionMatches der Klasse String

Abbildung 11.2: Der Aufruf von regionMatches

### 11.2.5 Suchen in Zeichenketten

    int indexOf(String s)
    int indexOf(String s, int fromIndex)
    int lastIndexOf(String s)
| java.lang.String

Die Methode `indexOf` sucht das erste Vorkommen der Zeichenkette `s` innerhalb des `String`-Objekts. Wird `s` gefunden, liefert die Methode den Index des ersten übereinstimmenden Zeichens zurück, andernfalls wird -1 zurückgegeben. Die Methode gibt es auch in einer Version, die einen Parameter vom Typ `char` akzeptiert. In diesem Fall sucht sie nach dem ersten Auftreten des angegebenen Zeichens.

Die zweite Variante von `indexOf` arbeitet wie die erste, beginnt mit der Suche aber erst ab Position `fromIndex`. Wird `s` beginnend ab dieser Position gefunden, liefert die Methode den Index des ersten übereinstimmenden Zeichens, andernfalls -1. Auch diese Methode gibt es in einer Variante, die anstelle eines `String`-Parameters ein Argument des Typs `char` erwartet. Ihr Verhalten ist analog zur vorherigen.

Die Methode `lastIndexOf` sucht nach dem letzten Vorkommen des Teilstrings `s` im aktuellen `String`-Objekt. Wird `s` gefunden, liefert die Methode den Index des ersten übereinstimmenden Zeichens, andernfalls -1. Wie die beiden vorherigen Methoden gibt es auch `lastIndexOf` wahlweise mit einem Parameter vom Typ `char` und mit einem zweiten Parameter, der die Startposition der Suche bestimmt.

### 11.2.6 Ersetzen von Zeichenketten

    String toLowerCase()
    String toUpperCase()

    String replace(char oldchar, char newchar)
| java.lang.String

Die Methode `toLowerCase` liefert den String zurück, der entsteht, wenn alle Zeichen des Argumentstrings in Kleinbuchstaben umgewandelt werden. Besitzt der String keine umwandelbaren Zeichen, wird der Original-String zurückgegeben. `toUpperCase` arbeitet ganz ähnlich, liefert aber den String, der entsteht, wenn alle Zeichen in Großbuchstaben umgewandelt werden. Besitzt der String keine umwandelbaren Zeichen, wird der Original-String zurückgegeben.

Mit Hilfe von `replace` wird eine zeichenweise Konvertierung des aktuellen String-Objekts durchgeführt. Dabei wird jedes Auftreten des Zeichens `oldchar` durch das Zeichen `newchar` ersetzt.

|  |  |  | Leider gibt es in der Klasse `String` keine Methode, die das Ersetzen von Teilstrings durch andere Teilstrings (von möglicherweise unterschiedlicher Länge) ermöglicht. Die auf Einzelzeichen basierende Methode `replace` ist das einzige Mittel, um überhaupt Ersetzungen vornehmen zu können. Seit der Version 1.2 gibt es im JDK aber in der Klasse `StringBuffer` eine entsprechende Methode. Sie wird in Abschnitt 11.4.4 beschrieben. |  |
Tip

### 11.2.7 Konvertierungsfunktionen

Da es oftmals nötig ist, primitive Datentypen in Zeichenketten umzuwandeln, bietet Java eine ganze Reihe von Methoden, die zu diesem Zweck entwickelt wurden. Allen Methoden ist der Name `valueOf` und die Tatsache, daß sie exakt einen Parameter erwarten, gemein.

Alle `valueOf`-Methoden sind als Klassenmethoden implementiert, d.h. sie können auch ohne ein `String`-Objekt aufgerufen werden. Dies macht Sinn, denn sie werden ja in aller Regel erst dazu verwendet, Strings zu erzeugen. Ein Aufruf von `valueOf` wandelt ein primitives Objekt mit Hilfe der Methode `toString`, die von der zugehörigen Wrapper-Klasse zur Verfügung gestellt wird, in eine Zeichenkette um. Die wichtigsten `valueOf`-Methoden sind:

    static String valueOf(boolean b)
    static String valueOf(char c)
    static String valueOf(char[] c)
    static String valueOf(double d)
    static String valueOf(float f)
    static String valueOf(int i)
    static String valueOf(long l)
    static String valueOf(Object obj)
| java.lang.String

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de