Vor Java 8 teilen wir uns auf leere Zeichenfolgen wie

String[] tokens = "abc".split("");

Der Aufteilungsmechanismus würde sich an Stellen aufteilen, die mit markiert sind |

|a|b|c|

weil ""vor und nach jedem Zeichen ein leerer Raum existiert. Als Ergebnis würde es zunächst dieses Array erzeugen

["", "a", "b", "c", ""]

und später werden nachfolgende leere Zeichenfolgen entfernt (da wir dem limitArgument keinen expliziten negativen Wert gegeben haben ), sodass es schließlich zurückkehrt

["", "a", "b", "c"]

In Java 8 scheint sich der Split-Mechanismus geändert zu haben. Nun, wenn wir verwenden

"abc".split("")

Wir werden ["a", "b", "c"]stattdessen ein Array erhalten, ["", "a", "b", "c"]so dass es so aussieht, als würden leere Zeichenfolgen beim Start ebenfalls entfernt. Aber diese Theorie scheitert zum Beispiel daran

"abc".split("a")

Gibt beim Start ein Array mit einer leeren Zeichenfolge zurück ["", "bc"].

Kann jemand erklären, was hier vor sich geht und wie sich die Split-Regeln in Java 8 geändert haben?

Das Verhalten von String.split(welches aufruft Pattern.split) ändert sich zwischen Java 7 und Java 8.

Dokumentation

Beim Vergleich zwischen der Dokumentation Pattern.splitin Java 7 und Java 8 wird die folgende Klausel hinzugefügt:

Wenn zu Beginn der Eingabesequenz eine Übereinstimmung mit positiver Breite vorliegt, wird am Anfang des resultierenden Arrays eine leere führende Teilzeichenfolge eingefügt. Eine Übereinstimmung mit der Breite Null am Anfang erzeugt jedoch niemals einen solchen leeren führenden Teilstring.

Dieselbe Klausel wird auch String.splitin Java 8 im Vergleich zu Java 7 hinzugefügt .

Referenzimplementierung

Vergleichen wir den Code Pattern.splitder Referenzimplemetation in Java 7 und Java 8. Der Code wird aus grepcode für die Versionen 7u40-b43 und 8-b132 abgerufen.

Java 7

public String[] split(CharSequence input, int limit) {
    int index = 0;
    boolean matchLimited = limit > 0;
    ArrayList<String> matchList = new ArrayList<>();
    Matcher m = matcher(input);

    // Add segments before each match found
    while(m.find()) {
        if (!matchLimited || matchList.size() < limit - 1) {
            String match = input.subSequence(index, m.start()).toString();
            matchList.add(match);
            index = m.end();
        } else if (matchList.size() == limit - 1) { // last one
            String match = input.subSequence(index,
                                             input.length()).toString();
            matchList.add(match);
            index = m.end();
        }
    }

    // If no match was found, return this
    if (index == 0)
        return new String[] {input.toString()};

    // Add remaining segment
    if (!matchLimited || matchList.size() < limit)
        matchList.add(input.subSequence(index, input.length()).toString());

    // Construct result
    int resultSize = matchList.size();
    if (limit == 0)
        while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
            resultSize--;
    String[] result = new String[resultSize];
    return matchList.subList(0, resultSize).toArray(result);
}

Java 8

public String[] split(CharSequence input, int limit) {
    int index = 0;
    boolean matchLimited = limit > 0;
    ArrayList<String> matchList = new ArrayList<>();
    Matcher m = matcher(input);

    // Add segments before each match found
    while(m.find()) {
        if (!matchLimited || matchList.size() < limit - 1) {
            if (index == 0 && index == m.start() && m.start() == m.end()) {
                // no empty leading substring included for zero-width match
                // at the beginning of the input char sequence.
                continue;
            }
            String match = input.subSequence(index, m.start()).toString();
            matchList.add(match);
            index = m.end();
        } else if (matchList.size() == limit - 1) { // last one
            String match = input.subSequence(index,
                                             input.length()).toString();
            matchList.add(match);
            index = m.end();
        }
    }

    // If no match was found, return this
    if (index == 0)
        return new String[] {input.toString()};

    // Add remaining segment
    if (!matchLimited || matchList.size() < limit)
        matchList.add(input.subSequence(index, input.length()).toString());

    // Construct result
    int resultSize = matchList.size();
    if (limit == 0)
        while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
            resultSize--;
    String[] result = new String[resultSize];
    return matchList.subList(0, resultSize).toArray(result);
}

Das Hinzufügen des folgenden Codes in Java 8 schließt die Übereinstimmung mit der Länge Null am Anfang der Eingabezeichenfolge aus, was das obige Verhalten erklärt.

            if (index == 0 && index == m.start() && m.start() == m.end()) {
                // no empty leading substring included for zero-width match
                // at the beginning of the input char sequence.
                continue;
            }

Kompatibilität aufrechterhalten

Folgendes Verhalten in Java 8 und höher

So splitverhalten Sie sich über Versionen hinweg konsistent und mit dem Verhalten in Java 8 kompatibel:

1. Wenn Ihre Regex mit einer Zeichenfolge mit der Länge Null übereinstimmen kann , fügen Sie sie einfach (?!\A)am Ende der Regex hinzu und verpacken Sie die ursprüngliche Regex in eine nicht erfassende Gruppe (?:...)(falls erforderlich).
2. Wenn Ihre Regex nicht mit einer Zeichenfolge mit der Länge Null übereinstimmen kann, müssen Sie nichts tun.
3. Wenn Sie nicht wissen, ob der reguläre Ausdruck mit einer Zeichenfolge mit der Länge Null übereinstimmen kann, führen Sie beide Aktionen in Schritt 1 aus.

(?!\A) Überprüft, ob die Zeichenfolge nicht am Anfang der Zeichenfolge endet. Dies bedeutet, dass die Übereinstimmung am Anfang der Zeichenfolge eine leere Übereinstimmung ist.

Folgendes Verhalten in Java 7 und früher

Es gibt keine allgemeine Lösung, um die splitAbwärtskompatibilität mit Java 7 und früheren Versionen zu gewährleisten, ohne alle Instanzen von splitzu ersetzen , um auf Ihre eigene benutzerdefinierte Implementierung zu verweisen.

Dies wurde in der Dokumentation von angegeben split(String regex, limit).

Wenn am Anfang dieser Zeichenfolge eine Übereinstimmung mit positiver Breite vorliegt, wird am Anfang des resultierenden Arrays eine leere führende Teilzeichenfolge eingefügt. Eine Übereinstimmung mit der Breite Null am Anfang erzeugt jedoch niemals einen solchen leeren führenden Teilstring.

In haben "abc".split("")Sie am Anfang eine Übereinstimmung mit der Breite Null erhalten, sodass der führende leere Teilstring nicht im resultierenden Array enthalten ist.

In Ihrem zweiten Snippet haben Sie jedoch beim "a"Teilen eine positive Breitenübereinstimmung erhalten (in diesem Fall 1), sodass der leere führende Teilstring wie erwartet enthalten ist.

(Irrelevanten Quellcode entfernt)

In den Dokumenten für split()Java 7 wurde eine geringfügige Änderung von Java 8 vorgenommen. Insbesondere wurde die folgende Anweisung hinzugefügt:

Wenn am Anfang dieser Zeichenfolge eine Übereinstimmung mit positiver Breite vorliegt, wird am Anfang des resultierenden Arrays eine leere führende Teilzeichenfolge eingefügt. Eine Übereinstimmung mit der Breite Null am Anfang erzeugt jedoch niemals einen solchen leeren führenden Teilstring.

^{(Hervorhebung von mir)}

Die Aufteilung der leeren Zeichenfolge generiert zu Beginn eine Übereinstimmung mit der Breite Null, sodass am Anfang des resultierenden Arrays keine leere Zeichenfolge gemäß den obigen Angaben enthalten ist. Im Gegensatz dazu "a"generiert Ihr zweites Beispiel, das sich aufteilt, am Anfang der Zeichenfolge eine positive Breitenübereinstimmung, sodass am Anfang des resultierenden Arrays tatsächlich eine leere Zeichenfolge enthalten ist.