Prima di Java 8, quando dividiamo su una stringa vuota come

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

il meccanismo di divisione si dividerebbe nei punti contrassegnati con |

|a|b|c|

perché lo spazio vuoto ""esiste prima e dopo ogni carattere. Quindi come risultato genererebbe inizialmente questo array

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

e successivamente rimuoverà le stringhe vuote finali (perché non abbiamo fornito esplicitamente un valore negativo limitall'argomento) in modo che alla fine tornerà

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

In Java 8 il meccanismo di divisione sembra essere cambiato. Ora quando usiamo

"abc".split("")

otterremo ["a", "b", "c"]array invece di ["", "a", "b", "c"]così sembra che anche le stringhe vuote all'inizio vengano rimosse. Ma questa teoria fallisce perché, ad esempio

"abc".split("a")

restituisce un array con una stringa vuota all'inizio ["", "bc"].

Qualcuno può spiegare cosa sta succedendo qui e come sono cambiate le regole di divisione in Java 8?

Il comportamento di String.split(che chiama Pattern.split) cambia tra Java 7 e Java 8.

Documentazione

Confrontando tra la documentazione Pattern.splitin Java 7 e Java 8 , osserviamo la seguente clausola che si aggiunge:

Quando c'è una corrispondenza di larghezza positiva all'inizio della sequenza di input, viene inclusa una sottostringa iniziale vuota all'inizio della matrice risultante. Una corrispondenza di larghezza zero all'inizio tuttavia non produce mai una sottostringa iniziale così vuota.

La stessa clausola viene aggiunta anche String.splitin Java 8 , rispetto a Java 7 .

Implementazione di riferimento

Confrontiamo il codice dell'implementazione Pattern.splitdi riferimento in Java 7 e Java 8. Il codice viene recuperato da grepcode, per le versioni 7u40-b43 e 8-b132.

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

L'aggiunta del seguente codice in Java 8 esclude la corrispondenza di lunghezza zero all'inizio della stringa di input, il che spiega il comportamento precedente.

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

Mantenere la compatibilità

Seguendo il comportamento in Java 8 e versioni successive

Per fare in splitmodo che si comporti in modo coerente tra le versioni e compatibile con il comportamento in Java 8:

1. Se la tua regex può corrispondere a una stringa di lunghezza zero, aggiungi semplicemente (?!\A)alla fine dell'espressione regolare e avvolgi la regex originale in un gruppo non di acquisizione (?:...)(se necessario).
2. Se la tua regex non può corrispondere a una stringa di lunghezza zero, non devi fare nulla.
3. Se non sai se la regex può abbinare o meno una stringa di lunghezza zero, esegui entrambe le azioni nel passaggio 1.

(?!\A) controlla che la stringa non finisca all'inizio della stringa, il che implica che la corrispondenza è una corrispondenza vuota all'inizio della stringa.

Seguendo il comportamento in Java 7 e precedenti

Non esiste una soluzione generale per rendere splitretrocompatibile con Java 7 e precedenti, a meno di sostituire tutte le istanze di splitper puntare alla propria implementazione personalizzata.

Questo è stato specificato nella documentazione di split(String regex, limit).

Quando c'è una corrispondenza di larghezza positiva all'inizio di questa stringa, viene inclusa una sottostringa iniziale vuota all'inizio della matrice risultante. Una corrispondenza di larghezza zero all'inizio tuttavia non produce mai una sottostringa iniziale così vuota.

In "abc".split("")hai una corrispondenza di larghezza zero all'inizio, quindi la sottostringa vuota iniziale non è inclusa nell'array risultante.

Tuttavia, nel secondo snippet, quando ci si divide, "a"si ottiene una corrispondenza di larghezza positiva (1 in questo caso), quindi la sottostringa iniziale vuota è inclusa come previsto.

(Rimosso codice sorgente irrilevante)

C'è stata una leggera modifica nei documenti per split()da Java 7 a Java 8. In particolare, è stata aggiunta la seguente dichiarazione:

Quando c'è una corrispondenza di larghezza positiva all'inizio di questa stringa, viene inclusa una sottostringa iniziale vuota all'inizio della matrice risultante. Una corrispondenza di larghezza zero all'inizio tuttavia non produce mai una sottostringa iniziale così vuota.

^{(enfasi mia)}

La divisione della stringa vuota genera una corrispondenza di larghezza zero all'inizio, quindi una stringa vuota non viene inclusa all'inizio della matrice risultante in conformità con quanto specificato sopra. Al contrario, il tuo secondo esempio che si divide su "a"genera una corrispondenza di larghezza positiva all'inizio della stringa, quindi una stringa vuota viene di fatto inclusa all'inizio della matrice risultante.