CodeGym/Java-Blog/Germany/Java: String-Split-Methode
Autor
Alex Vypirailenko
Java Developer at Toshiba Global Commerce Solutions

Java: String-Split-Methode

Veröffentlicht in der Gruppe Germany
Sehen wir uns die Methode String.split in Java an: was sie tut und warum wir sie brauchen. Es ist nicht schwer zu erraten, dass sie einen Java-String aufteilt, aber wie funktioniert das in der Praxis? Wir wollen tief in die Funktionsweise der Methode eintauchen und einige nicht so offensichtliche Details besprechen. Gleichzeitig lernen wir, wie viele split-Methoden String tatsächlich hat. Los geht's!Java: String-Split-Methode - 1

Beschreibung und Signatur für String.split in Java

In Java zerlegt die split-Methode eine Zeichenkette in Teilstrings unter Verwendung eines mit einem regulären Ausdruck definierten Trennzeichens. Sehen wir uns erstmal die Signatur der Methode an und tauchen dann tiefer ein:
String[] split(String regex)
Zwei Dinge sind aus der Signatur ersichtlich:
  1. Die Methode gibt ein Array von Strings zurück.
  2. Die Methode hat einen String-Eingabeparameter namens regex.
Lass uns jeden dieser Punkte einzeln analysieren, während wir die oben gegebene Beschreibung auseinander nehmen.
  1. Die Methode gibt ein Array von Strings zurück.

    Die Erklärung enthält die folgenden Worte: „In Java zerlegt die split-Methode eine Zeichenkette in Teilstrings“. Die Methode sammelt diese Teilstrings in einem Array, das zum Rückgabewert wird.

  2. Die Methode hat einen String-Eingabeparameter namens regex.

    Erinnern wir uns abermals an die Beschreibung: „zerlegt eine Zeichenkette in Teilstrings unter Verwendung eines mit einem regulären Ausdruck definierten Trennzeichens“. Der Eingabeparameter regex ist ein regulärer Ausdruck, der auf die ursprüngliche Zeichenkette angewendet wird. Wenn das Zeichen oder die Zeichenkombination übereinstimmen, werden sie als Trennzeichen behandelt.

Java split String split in der Praxis

Kommen wir nun zur praktischen Anwendung. Stellen wir uns vor, wir haben einen String aus Wörtern. Zum Beispiel:
Ich liebe Java
Wir müssen diese Zeichenketten in Wörter aufteilen. Wir sehen, dass die Wörter in dieser Zeichenkette durch Leerzeichen voneinander getrennt sind. In diesem Fall ist ein Leerzeichen der perfekte Kandidat für unser Trennzeichen. Der Code zur Lösung unserer Aufgabe würde also wie folgt aussehen:
public class Main {
    public static void main(String[] args) {
        String str = "I love Java";
        String[] words = str.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}
Die Ausgabe der main-Methode besteht aus den folgenden Zeilen:
Ich liebe Java
Sehen wir uns ein paar weitere Beispiele an, wie die split-Methode funktionieren würde:
String Trennzeichen Ergebnis der Methode
"Ich liebe Java" " " (Leerzeichen) {"Ich", "liebe", "Java"}
"192.168.0.1:8080" ":" {"192.168.0.1", "8080"}
"Rot, orange, gelb" "," {"Rot", " orange", " gelb"}
"Rot, orange, gelb" ", " {"Rot", "orange", "gelb"}
Beachte die Unterschiede zwischen den letzten beiden Zeilen in der obigen Tabelle. In der vorletzten Zeile wird ein Komma als Trennzeichen verwendet. Als Ergebnis haben einige der Wörter führende Leerzeichen, wenn die Zeichenkette aufgeteilt wird. In der letzten Zeile haben wir ein Komma und ein Leerzeichen als Trennzeichen verwendet. Deshalb gab es im resultierenden Array keine Teilstrings mit führenden Leerzeichen. Dies ist nur ein kleines Detail, das zeigt, wie wichtig es ist, das richtige Trennzeichen sorgfältig auszuwählen.

Führendes Trennzeichen

Dies ist ein weiterer wichtiger Aspekt. Wenn die ursprüngliche Zeichenkette mit dem Trennzeichen beginnt, ist das erste Element des resultierenden Arrays eine leere Zeichenkette. Das würde zum Beispiel so aussehen: Ursprünglicher String: " Ich liebe Java" Trennzeichen: " " Resultierendes Array: { "", "Ich", "liebe", "Java" } Wenn die ursprüngliche Zeichenkette jedoch mit einem Trennzeichen endet, statt mit einem zu beginnen, sieht das Ergebnis anders aus: Ursprünglicher String: "Ich liebe Java " Trennzeichen: " " Resultierendes Array: { "Ich", "liebe", "Java" } Sieh dir den Code an und beachte, wie die split-Methode mit einem Trennzeichen am Ende und/oder am Anfang der ursprünglichen Zeichenkette anders funktioniert:
public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" "));
        print(" I love Java".split(" "));
        print("I love Java ".split(" "));
        print(" I love Java ".split(" "));
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}
Die Ausgabe der main-Methode sieht dann so aus:
[Ich, liebe, Java] [, Ich, liebe, Java] [Ich, liebe, Java] [, Ich, liebe, Java]
Beachte, dass, wenn das erste Zeichen in der ursprünglichen Zeichenkette ein Trennzeichen ist, dies zur Folge hat, dass das erste Element im Array eine leere Zeichenkette sein wird.

Überladene Schwester

Die Klasse String hat eine weitere split-Methode mit folgender Signatur:
String[] split(String regex, int limit)
Diese Methode hat den zusätzlichen Parameter limit: Er bestimmt, wie oft das regex-Muster auf die ursprüngliche Zeichenkette angewendet wird. Siehe die Erklärungen unten:

limit > 0

Das Muster wird limit-1 Mal angewendet. Außerdem wird die Länge des zurückgegebenen Arrays den Wert des limit-Parameters nicht überschreiten. Das letzte Element des Arrays ist der Teil der Zeichenkette, der auf die letzte Stelle folgt, an der das Trennzeichen gefunden wurde. Beispiel:
public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Output:
         [I love Java]
         [I, love Java]
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limit < 0

Der reguläre Ausdruck für das Trennzeichen wird so oft wie möglich auf die Zeichenkette angewendet. Das resultierende Array kann eine beliebige Länge haben. Beispiel:
public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Output:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Please note that the last element of the array is
        an empty string. This is caused by the whitespace
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limit = 0

Wie in dem Fall, in dem limit < 0 ist, wird das Trennzeichenmuster so oft wie möglich auf die Zeichenkette angewendet. Das endgültige Array kann eine beliebige Länge haben. Wenn die letzten Elemente leere Strings sind, werden sie aus dem endgültigen Array verworfen. Beispiel:
public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Output:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Note the absence of empty strings at the end of the arrays
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}
Wenn wir einen Blick auf die Implementierung der Ein-Parameter-Version der split-Methode werfen, dann sehen wir, dass sie wie ihre überladene Schwester funktioniert, wenn das zweite Argument auf Null gesetzt wäre:
public String[] split(String regex) {
    return split(regex, 0);
}

Verschiedene Beispiele

In der Praxis kommt es manchmal vor, dass wir Zeichenketten haben, die nach bestimmten Regeln erzeugt werden. Ein solcher String kann von überall her in unser Programm kommen:
  • von einem Drittanbieter-Dienst;
  • von einer an unseren Server gesendeten Anfrage;
  • von einer Konfigurationsdatei;
  • und so weiter.
In diesen Situationen kennt der Programmierer normalerweise die „Spielregeln“. Nehmen wir an, ein Programmierer weiß, dass er es mit Benutzerinformationen zu tun hat, die nach diesem Muster gespeichert sind:
Benutzer-ID|Benutzer-Login|Benutzer-E-Mail
Nehmen wir einige konkrete Werte als Beispiel:
135|bender|bender@gmail.com
Angenommen, die Aufgabe des Programmierers ist es, eine Methode zu schreiben, die eine E-Mail an den Benutzer sendet. Der Programmierer hat Zugriff auf die Benutzerdaten, die in dem oben angegebenen Format gespeichert werden. Die Teilaufgabe, die wir nun weiter analysieren werden, ist die Isolierung der E-Mail-Adresse vom Rest der Benutzerdaten. Hierbei kann uns die split-Methode sehr nützlich sein. Denn wenn wir uns die Benutzerdatenvorlage ansehen, stellen wir fest, dass das Extrahieren der E-Mail-Adresse des Benutzers durch einen einfachen Aufruf der split-Methode zur Aufteilung der Zeichenkette möglich ist. Dann wird die E-Mail-Adresse im letzten Element des resultierenden Arrays stehen. Hier ist ein Beispiel für eine Methode, die eine Zeichenkette mit Benutzerdaten entgegennimmt und die E-Mail-Adresse des Benutzers zurückgibt. Der Einfachheit halber nehmen wir an, dass der Datenstring immer in dem gewünschten Format vorliegt:
public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Output: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // or data[data.length - 1]
    }
}
Beachte das Trennzeichen "\\|". In regulären Ausdrücken ist „|“ ein Sonderzeichen mit besonderer Bedeutung. Wenn wir also ein gewöhnliches Zeichen verwenden wollen (d. h. wir in der ursprünglichen Zeichenkette finden möchten), dann müssen wir das Zeichen mit zwei Backslashes escapen. Betrachten wird ein anderes Beispiel. Nehmen wir an, wir haben Bestellinformationen, die wie folgt strukturiert sind:
Artikelnummer_1,Artikelname_1,Artikelpreis_1;Artikelnummer_2,Artikelname_2,Artikelpreis_2;...;Artikelnummer_n,Artikelname_n,Artikelpreis_n
Wir können sogar ein paar konkrete Werte nehmen:
1,Gurken,2.39;2,Tomaten,1.89;3,Speck,4.99
Unsere Aufgabe ist es, die Gesamtkosten für die Bestellung zu berechnen. Hier werden wir die split-Methode mehrmals anwenden müssen. Der erste Schritt besteht darin, die Zeichenkette mit „;“ als Trennzeichen aufzuteilen, um sie in ihre Bestandteile zu zerlegen. Dann wird jeder resultierende Teilstring Informationen über ein separates Produkt enthalten, die wir später verarbeiten können. Dann werden wir für jedes Produkt die entsprechenden Informationen mit dem Symbol „,“ aufteilen. Wir nehmen ein Element mit einem bestimmten Index (das, in dem der Produktpreis gespeichert ist) aus dem resultierenden String-Array, wandeln es in eine numerische Form um und zählen die Gesamtkosten der Bestellung zusammen. Lass uns eine Methode schreiben, die alle diese Berechnungen durchführt:
public class Main {
    public static void main(String[] args) {
        String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 9.27
    }

    static double getTotalOrderAmount(String orderInfo) {
        double totalAmount = 0d;
        final String[] items = orderInfo.split(";");

        for (String item : items) {
            final String[] itemInfo = item.split(",");
            totalAmount += Double.parseDouble(itemInfo[2]);
        }

        return totalAmount;
    }
}
Versuche einmal selbst herauszufinden, wie diese Methode funktioniert. Ausgehend von diesen Beispielen können wir sagen, dass die split-Methode verwendet wird, wenn wir Daten haben, die als String formatiert sind, und wir bestimmte konkrete Informationen daraus extrahieren müssen.

Zusammenfassung

Wir haben die split-Methode der String-Klasse kennengelernt. Sie ist die ideale Lösung, wenn man eine Zeichenkette mithilfe eines speziellen Trennzeichens in ihre Bestandteile aufteilen muss. Die Methode gibt ein Array von Strings zurück (die Teilstrings, aus denen der ursprüngliche String besteht). Sie nimmt einen regulären Ausdruck entgegen, dessen Übereinstimmungen das/die Trennzeichen darstellen. Wir haben verschiedene Details dieser Methode unter die Lupe genommen:
  • ein führendes Trennzeichen;
  • ihre überladene Schwester mit zwei Parametern.
Wir haben außerdem versucht, ein paar Situationen aus dem wirklichen Leben zu modellieren, in denen wir die split-Methode verwenden konnten, um hypothetische, aber recht praxisnahe Probleme zu lösen.
Kommentare
  • Beliebt
  • Neu
  • Alt
Du musst angemeldet sein, um einen Kommentar schreiben zu können
Auf dieser Seite gibt es noch keine Kommentare