====== Strings (Zeichenketten) ======

===== Deklaration von Zeichenketten =====
Jede Zeichenkette ist eigentlich ein [[http://java.sun.com/javase/6/docs/api/java/lang/String.html|Objekt vom Typ String]]. Zur Verarbeitung von Zeichenketten stehen daher Instanzvariable oder Methoden der Klasse String zur Verfügung. Da die Klasse String in der Bibliothek java.lang  definiert ist, steht sie allen Java-Programmen zur Verfügung.
<code java>
String s = new String();
</code>

erzeugt eine leere Zeichenkette.

==== Zeichenketten initialisieren ====

Im obigen Beispiel wurde genaugenommen der Standardkonstruktor für die Klasse String verwendet. Ein String wird durch die Angabe einer Zeichenkette initialisiert.

<code java>
String s = new String("Informatik ist schön!");
</code>

==== Initialisierung durch char-Arrays ====

Zur Klasse String existiert ein Konstruktor, der Arrays in die Zeichenkette überträgt:

<code java>
public class string2 {
    public static void main(String [] args) {
        char text[] = {'I','n','f','o','r','m','a','t','i','k'};
        String s = new String(text);
        System.out.println(s);
    }
}
</code>

Wir erhalten die Ausgabe

''Informatik''

Durch die Angabe des Index und der Anzahl der Zeichen werden die Zeichen teilweise aus dem Array übernommen:

<code java>
public class string2 {
    public static void main(String [] args) {
        char text[] = {'I','n','f','o','r','m','a','t','i','k'};
        String s = new String(text,2,4);
        System.out.println(s);
    }
}
</code>

Damit erhalten wir erwartungsgemäß

''form''

==== Initialisierung durch byte - Array ====

Auch byte - Arrays können zur Initialisierung einer Zeichenkette übergeben werden:

<code java>
public class string3 {
    public static void main(String [] args) {
        byte text[] = {73, 78, 70, 79};
        String s = new String(text);
        System.out.println(s);
    }
}
</code>

Wir erhalten:

''INFO''

Bei diesem Konstruktor kann ebenfalls der Startindex und die Anzahl der ausgelesenen Bytes angegeben werden. 

[[http://goascii.com/|ASCII-Tabelle]]

===== String - Methoden =====

Für die Klasse [[http://java.sun.com/javase/6/docs/api/java/lang/String.html#method_summary|string existieren zahlreiche Methoden]] zur Handhabung der Zeichenketten. Die wichtigsten davon sollen in diesem Abschnitt vorgestellt werden. 

==== Länge einer Zeichenkette ermitteln ====

**int length()**

<code java>
public class string4 {
    public static void main(String [] args) {
        String s = new String("Informatik ist schön");
        System.out.println(s.length());
    }
}
</code>

==== Ein bestimmtes Zeichen einer Zeichenkette ausgeben ====

**charAt (int Position)**

<code java>
public class string4 {
    public static void main(String [] args) {
        String s = new String("Informatik ist schön");
        for (int i=0; i < s.length(); i++) {
            System.out.print(s.charAt(i));
        }
    }
}
</code>

==== Weitere wichtige String-Methoden ====

**getChars()**

Einzelne Zeichen auslesen. Während mit ''charAt()'' ein einzelnes Zeichen mit dem angegebenen Index ausgewählt wird, erlaubt ''getChars(int start, int ende, char ergebnis[], int start_ergebnis)'' die Auswahl einer zusammenhängenden Zeichenkette, die die Zeichen von ''start'' bis ''ende'' enthält. Das Ergebnis wird in den Array ergebnis, beginnend mit dem Index ''start_ergebnis'' geschrieben. 

**indexOf()**

Die Position eines Zeichens (bzw. Zeichenkette) bestimmen. Die Methode indexOf gibt dabei das erste Auftreten dieses Zeichens (bzw. Zeichenkette) zurück. 

**substring()**

Eine Teilzeichenkette ermitteln. Die Zeichenkette wird entweder mit Hilfe eines einzigen Index (''Startindex'') oder an Hand zweier Indizes (''Startindex'', ''Endindex'') bestimmt. 

**replace()**

In der ganzen Zeichenkette ein bestimmtes Zeichen durch ein anderes ersetzen. ''replace(char original, char neu)'' ersetzt alle Zeichen ''original'' durch Zeichen ''neu''. 

**trim()**

Liefert die Zeichenkette zurück, die vorangehende und abschließende nicht druckbare Zeichen entfernt. 


===== Operatoren für Zeichenketten =====

==== Verkettung von Zeichenketten ====

Zeichenketten werden entweder mit dem binären Operator ''+''  oder mit der Methode ''concat()'' verkettet.

<code java>
public class string5 {
    public static void main(String [] args) {
        String s1 = new String("Informatik");
        String s2 = new String("ist");
        String s3 = new String("schön");
        String nl = new String(" ");
        System.out.println(s1 + nl + s2 + nl + s3 + "!");
        System.out.println(s2.concat(nl).concat(s1).concat(nl).concat(s3).concat("?"));
    }
}
</code>

Beachte, wie in der letzten Zeile die String-Methode ''concat()'' jeweils auf die bereits erhaltene Zeichenkette angewendet wird! 

==== Ausgeben von Zeichenketten und Variablenwerten ====

Wird eine Zeichenkette mit einem Variablennamen verkettet, so wird zunächst der Zeichenkettenwert der Variablen ermittelt. Dieser wird mit der schon angegebenen Zeichenkette verkettet.

<code java>
public class string6 {
    public static void main(String [] args) {
        int a = 10;
        int b = 20;

        System.out.println(a + " + " + b + " = " + a + b);
        System.out.println(a + " + " + b + " = " + (a + b));
    }
}
</code>

Beachte die Verwendung von Gruppierungsklammern! Jedenfalls entsteht der folgende Output:

<file>
10 + 20 = 1020
10 + 20 = 30
</file>

==== Der Vergleich von Zeichenketten ====

Der Vergleich von Zeichenketten spielt beispielsweise für die Programmsteuerung oder für datenbankähnliche Anwendungen eine Rolle. Da die Variablennamen für Zeichenketten aber die Adresse enthalten, können einfache Vergleichsoperatoren wie ''=='' oder ''!=''  nicht verwendet werden. An ihre Stelle treten bestimmte String-Methoden.

Warum liefert der folgende Vergleich den Boole'schen Wert false?

<code java>
public class string7 {
    public static void main(String [] args) {
        String s = new String("hallo");
        System.out.println("hallo" == s);
    }
}
</code>

liefert

''false''


==== Die Methode equals() ====

Das folgende Beispiel zeigt einen korrekten Vergleich von Zeichenketten:

<code java>
public class string8 {
    public static void main(String [] args) {
        String s = new String("hallo");
        System.out.println(s.equals("hallo"));
    }
}
</code>

liefert "wunschgemäß"

''true''

Die Methode ''equals()'' liefert jedenfalls Boole'sche Werte zurück. 


==== Weitere Vergleichsmethoden für Zeichenketten ====

Je nach Anwendung werden verschiedene, leistungsfähige Vergleichsmethoden verwendet. Einige davon werden hier angeführt:

**equalsIgnoreCase()**

Beim Zeichenkettenvergleich wird die Groß/Kleinschreibung ignoriert. Das Ergebnis ist ein Boole'scher Wert. 

**startsWith()**

Stellt fest, ob eine Zeichenkette mit einer bestimten Zeichenfolge beginnt. Das Ergebnis ist ein Boole'scher Wert. 

**endsWith()**

Stellt fest, ob eine Zeichenkette mit einer bestimten Zeichenfolge endet. Das Ergebnis ist ein Boole'scher Wert. 

**compareTo()**

Überprüft neben der Gleichheit der Zeichenketten die alphabetische Abhängigkeiten (vgl. Wörterbuch). Das Ergebnis ist eine ganze Zahl: Steht die aufrufende Zeichenfolge im Wörterbuch vor der angegebenen, so liefert compareTo() eine negative Zahl; bei Gleichheit Null. Steht die aufrufende Zeichenkette im Wörterbuch nach der angegebenen, so ist das Ergebnis eine positive Zahl. 

<code java>
public class string9 {
    public static void main(String [] args) {
        String s = new String("hallo");
        
        System.out.println("hallo: " + s.compareTo("hallo"));
        System.out.println("ha: " + s.compareTo("ha"));
        System.out.println("Hallo: " + s.compareTo("Hallo"));
        System.out.println("abc: " + s.compareTo("abc"));
        System.out.println("hallo - ist da jemand: " + s.compareTo("hallo - ist da jemand"));
        System.out.println("huch: " + s.compareTo("huch"));
    }
}
</code>

liefert die folgenden Ergebnisse:

<file>
hallo: 0
ha: 3
Hallo: 32
abc: 7
hallo - ist da jemand: -16
huch: -20
</file>

==== Eine Wörterliste sortieren (Bubble-Sort) ====

Das folgende kleine Programm sortiert die Wörter eines Satzes. Alle Wörter werden in ein Array eingetragen, dessen Werte anschließend auf ihre alphabetische Reihenfolge überprüft werden. Stimmt die Reihenfolge nicht, so werden die Werte einfach ausgetauscht...

<code java>
public class string10 {
    public static void main(String [] args) {
        String satz[] = {"informatik", "ist", "schön", "und", "lehrer", "lügen", "nicht"};
        for (int i = 0; i < satz.length; i++) {
            for (int j = i+1; j < satz.length; j++) {
                if (satz[j].compareTo(satz[i]) < 0) {
                    String wort = satz[i];
                    satz[i] = satz[j];
                    satz[j] = wort;
                }
            }
            System.out.println(satz[i]);
        }
    }
}
</code>

Im Beispiel erhalten wir folgende Ausgabe:

<file>
informatik
ist
lehrer
lügen
nicht
schön
und
</file>

===== Die Klasse StringBuffer =====

Ein einmal erzeugtes String - Objekt kann im Nachhinein nicht mehr verändert werden. Für Anwendungen, die veränderbare Zeichenketten benötigen, wird die Klasse [[http://java.sun.com/javase/6/docs/api/java/lang/StringBuffer.html|StringBuffer]]  verwendet. 

==== Die Reihenfolge der Zeichen umkehren ====

<code java>
public class string12 {
    public static void main(String [] args) {
        StringBuffer s = new StringBuffer("informatik");
        System.out.println(s);
        s.reverse();
        System.out.println(s);
    }
}
</code>

ergibt die folgenden Zeilen:

<file>
informatik
kitamrofni
</file>


==== Befehlszeilenargumente verwenden ====

Bestimmt erhebt sich schon längst die Frage, welche Rolle die Parameterliste der Hauptmethode ''main(String [] args)'' spielt. Wir überprüfen dies im nächsten Beispiel...

<code java>
public class string13 {
    public static void main(String [] args) {
        for (int i=0; i<args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}
</code>
Damit erhalten wir folgende Ausgaben:

<file>
alfred@duron:~/java/kurs> java string13 Informatik ist schön
args[0]: Informatik
args[1]: ist
args[2]: schön
alfred@duron:~/java/kurs>
</file>

Es ist leicht zu erkennen, wie die ``auf der Kommandozeile'' eingegebenen Parameter mit Hilfe des Zeichenketten-Feldes aufgerufen und innerhalb der eigenen Klasse verwendet werden können.