Strings (Zeichenketten)

Jede Zeichenkette ist eigentlich ein 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.

String s = new String();

erzeugt eine leere Zeichenkette.

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

String s = new String("Informatik ist schön!");

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

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);
    }
}

Wir erhalten die Ausgabe

Informatik

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

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);
    }
}

Damit erhalten wir erwartungsgemäß

form

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

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

Wir erhalten:

INFO

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

ASCII-Tabelle

Für die Klasse string existieren zahlreiche Methoden zur Handhabung der Zeichenketten. Die wichtigsten davon sollen in diesem Abschnitt vorgestellt werden.

int length()

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

charAt (int Position)

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));
        }
    }
}

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.

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

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("?"));
    }
}

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

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

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));
    }
}

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

10 + 20 = 1020
10 + 20 = 30

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?

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

liefert

false

Das folgende Beispiel zeigt einen korrekten Vergleich von Zeichenketten:

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

liefert „wunschgemäß“

true

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

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.

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"));
    }
}

liefert die folgenden Ergebnisse:

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

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…

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]);
        }
    }
}

Im Beispiel erhalten wir folgende Ausgabe:

informatik
ist
lehrer
lügen
nicht
schön
und

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 StringBuffer verwendet.

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

ergibt die folgenden Zeilen:

informatik
kitamrofni

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…

public class string13 {
    public static void main(String [] args) {
        for (int i=0; i<args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

Damit erhalten wir folgende Ausgaben:

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

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.