String

---

---

Wenn man folgenden Code schreibt:

String s = "Hallo";

dann wird kein Konstruktor aufgerufen, man könnte theoretisch von einem "leeren Konstruktor" sprechen. Durch diesen Befehl wird ein String-Literal mit dem Wert "Hallo" erzeugt. Solche Literale werden vom Compiler schon beim Übersetzen erkannt und in den sogenannten String-Pool gelegt. Die Referenzvariable s zeigt dann auf die entsprechende Stelle in diesem String-Pool.

String()↑

---

Das ist der einfachste Konstruktor der Klasse String, mit dem man auf einfache Weise ein Objekt der Klasse String erzeugen kann.

String s = new String("Hallo");

String(byte[])↑

---

Dieser Konstruktor, der nur selten verwendet wird, liest einen byte-Array aus und erzeugt daraus ein Objekt der Klasse String.

// Ein Array von Bytes mit ASCII-Werten
// entspricht "Hallo".
   byte[] daten = {72, 97, 108, 108, 111};

// String-Konstruktor mit Byte-Array
   String text = new String(daten);

  System.out.println(text);  // ⟹ "Hallo"

String(char[])↑

---

Ähnlich wie der vorherige Konstruktor, nur dass hier kein byte-Array, sondern ein char-Array übergeben wird.

String(String)↑

---

Dieser Konstruktor dient im Prinzip zum Kopieren eines String-Objektes. Es wird ein neues String-Objekt mit dem gleichen Inhalt (aber einer anderen Speicheradresse) wie der Original-String erzeugt.

concat(String)↑

---

Syntax:

String concat(String: suffix)

Rückgabewert:

Ein neues String-Objekt, das aus dem alten String und dam angehängten Suffix-String besteht.

Funktion:

Zusammenfügen (Konkatenieren) von zwei Strings

Codebeispiel:

String s = "Hallo";
String t = s.concat(" Welt");  
// t = "Hallo Welt"
t = t.concat(", bis dann...");   
// t = "Hallo Welt, bis dann..."

Anmerkungen:

Variablen der Klasse String sind nicht veränderbar. Man kann also einen String nicht direkt verlängern oder verkürzen, sondern muss immer ein neues String-Objekt anlegen, dass dann diese Veränderung enthält. Das ursprüngliche String-Objekt bleibt dabei unverändert (immutable).

Die letzte Zeile in diesem Codebeispiel zeigt, dass ein String sich auch selbst verlängern kann. Auf den ersten Blick sieht es dabei so aus, als würde die String-Variable t doch verändert werden, aus "Hallo Welt" wird "Hallo Welt, bis dann...".

Ganz so einfach ist die Sache aber nicht. In Wirklichkeit wird die Variable t "an einer anderen Stelle im Speicher völlig neu erzeugt, während die alte Variable t gelöscht wird.

length()↑

---

Syntax:

int length()

Rückgabewert:

Länge des Strings (Anzahl der Zeichen).

Funktion:

Liefert die Zeichenanzahl bzw. Länge des Strings zurück.

Codebeispiel:

String s = "Hallo";
int n = s.length();  // 5

Anmerkungen:

Auch Leerzeichen zählen bei der Länge eines Strings mit!

charAt(int index)↑

---

Syntax:

char charAt(int index)

Rückgabewert:

Zeichen (char) an der Position index.

Funktion:

Auslesen eines einzelnen Zeichens.

Codebeispiel:

char c = "Hallo".charAt(1); // 'a'

Anmerkung:

Achten Sie darauf, dass das erste Zeichen eines Strings den Index 0 hat - wie bei einem Array.

substring(int von)↑

substring(int von, int bis)

---

Syntax:

String substring(int v)

String substring(int v, int b)

Rückgabewert:

Teilstring, beginnend bei Index v bis Index b-1 oder bis zum Ende des Strings, falls der zweite Parameter nicht angegeben wird. Achtung: Das Zeichen an Index b des Strings wird nicht mehr in den Substring kopiert!

Funktion:

Schneidet einen Teilstring aus dem String aus, ohne diesen zu verändern.

Codebeispiel:

String s = "Informatik";
String t1 = s.substring(3);      
// "ormatick"
String t2 = s.substring(3, 7);   
// "orma" und nicht "ormat" 

indexOf(String)↑

indexOf(String, int)

---

Syntax:

int indexOf(String s)

int indexOf(String s, int n)

Rückgabewert:

Startindex des ersten Vorkommens von s bzw. des n. Vorkommens von s (zweiter Konstruktor).

Funktion:

Sucht einen Teilstring in einem String und liefert dessen Position zurück.

Codebeispiel:

int i1 = "Mississippi".indexOf('s'); // ⟹ 2
int i2 = "Mississippi".indexOf("iss", 2); // ⟹  4

contains(String)↑

---

Syntax:

boolean contains(String s)

Rückgabewert:

true, falls der übergebene String in den untersuchten String vorkommt.

Funktion:

Überprüft, ob ein Teilstring in einem String vorkommt. Die Position wird nicht zurückgeliefert.

Codebeispiel:

boolean ok = "Willkommen".contains("komm"); 
// true

startsWith(String)↑

endsWith(String)

---

Syntax:

boolean startsWith(String s)

boolean endsWith(String s)

Rückgabewert:

true, falls der untersuchte String mit dem Parameter anfängt bzw. endet.

Funktion:

Überprüft, ob der zu untersuchende String mit dem String-Parameter beginnt oder endet.

Codebeispiel:

String  s  = "Private Hochschule";
boolean ok = s.startsWith("Private"); // true
        ok = s.endsWith("ule");       // true
		  ok = s.endsWith("Hoch");      // false

equals(String)↑

equalsIgnoreCase(String)

---

Syntax:

boolean equals(String s)

boolean equalsIgnorecase(String s)

Rückgabewert:

true, falls der untersuchte String den gleichen Inhalt hat wie der übergebene String.

Funktion:

Vergleicht den Inhalt von zwei String-Objekten, nicht die Speicheradressen. Die Methode equalsIgnoreCase() ignoriert bei diesem Vergleich die Groß- und Kleinschreibung der beiden Strings.

Codebeispiel:

String  s  = "Private Hochschule";
String  t  = "Private Hochschule"
boolean b  = s.equals(t);          // true;
boolean c  = (s == t);             // false;

Anmerkung:

Das letzte Beispiel soll verdeutlichen, dass man zwei Strings niemals (!) mit dem Gleichheits-Operator == vergleichen darf. Dieser Operator überprüft, ob sich die beiden String-Objekte an der gleichen Speicheradresse befinden und nicht ob sie den gleichen Inhalt haben. Zum Überprüfen der Inhalts-Gleichzeit immer equals() einsetzen.

Weitere Anmerkung:

Der Methode String.equals() kann man jedes beliebige Objekt als Parameter übergeben; die Signatur der Methode lautet

public boolean equals(Object einObjekt)

Der Compiler erzeugt keine Fehlermeldung, wenn hier beispielsweise ein Objekt der Klasse Gegenstand oder Person übergeben wird. Ob der Aufruf von equals() dann noch Sinn macht, ist natürlich eine andere Frage.

Die Klasse String hat die Methode equals() von der Klasse Object geerbt. Das heißt, alle Java-Objekte verfügen über diese Methode.

compareTo(String)↑

---

Syntax:

int compareTo(String s)

Rückgabewert:

• negativer Wert: Der String kommt alphabetisch vor dem übergebenem String s
• positiver Wert: Der String kommt alphabetisch nach dem übergebenem String s
• 0 : Beide Strings sind exakt gleich

Funktion:

Während equals() auf absolute Gleichheit überprüft, kann man mit compareTo() herausfinden, welcher der beiden Strings in der alphabetischen Reihenfolge zuerst kommt.

Codebeispiel:

String  s  = "Private Hochschule";
String  t  = "Staatliche Hochschule"
int b  = s.comparesTo(t);          // negativer Wert

Anmerkung:

Bei dem lexikalischen Vergleich der beiden Strings wird zeichenweise vorgegangen. In dem obigen Beispiel unterscheiden sich bereits die ersten Zeichen der beiden Strings, daher steht die Entscheidung schon sofort fest. Wenn die ersten Zeichen gleich sind, werden die zweiten Zeichen untersucht, dann die dritten und so weiter. Großbuchstaben kommen alphabetisch vor Kleinbuchstaben, und die Ziffern 0 bis 9 kommen vor den Buchstaben. Grundlage für diesen Vergleich sind die Unicodes der Zeichen.

Dieses Bild zeigt einen Ausschnitt aus der großen Unicode-Tabelle auf symbl.cc.