Pourquoi dans Java 8 split parfois supprime les cordes à vide au début de la matrice de résultats?

Le comportement de String.split (qui appelle Pattern.split) les changements entre Java 7 et Java 8.

Documentation

La comparaison entre les documents de Pattern.split dans Java 7 et Java 8, nous observons la clause suivante est ajoutée:

Quand il y a un effet positif-largeur match au début de la séquence d'entrée vide leader de la sous-chaîne est inclus au début de la matrice résultante. Une largeur nulle match au début cependant jamais produit un tel vide leader de la sous-chaîne.

La même clause est également ajouté à String.split dans Java 8, par rapport à Java 7.

L'implémentation de référence de

Laissez-nous comparer le code de Pattern.split de la référence de mise en œuvre en Java 7 et Java 8. Le code est extrait de grepcode, pour la version 7u40-b43 et 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'ajout du code en Java 8 exclut la longueur nulle match au début de la chaîne d'entrée, ce qui explique le comportement ci-dessus.

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

Maintenir la compatibilité de

Problème suivant dans Java 8 et ci-dessus

De faire split se comporte de manière uniforme entre les versions et compatible avec le comportement en Java 8:

1. Si votre regex peut correspondre à une chaîne de longueur nulle, il suffit d'ajouter (?!\A) à la fin de la regex et enveloppez-la d'origine regex dans la non-capture d'un groupe (?:...) (si nécessaire).
2. Si votre regex ne peut pas match chaîne de longueur zéro, vous n'avez pas besoin de faire quoi que ce soit.
3. Si vous ne savez pas si l'expression rationnelle peut correspondre à une chaîne de longueur nulle ou pas, de faire à la fois les actions de l'étape 1.

(?!\A) vérifie que la chaîne n'a pas de fin au début de la chaîne, ce qui implique que le match est vide match au début de la chaîne.

Problème suivant dans Java 7 et avant

Il n'y a pas de solution générale pour faire split vers l'arrière-compatible avec Java 7 et avant, court de remplacement de tous instance de split pour pointer vers votre propre mise en œuvre.

OriginalL'auteur nhahtdh

Il y avait un léger changement dans les docs pour split() à partir de Java 7 de Java 8. Plus précisément, la déclaration suivante a été ajoutée:

Quand il y a un effet positif-largeur match au début de cette chaîne vide leader de la sous-chaîne est inclus au début de la matrice résultante. Une largeur nulle match au début cependant jamais produit un tel vide leader de la sous-chaîne.

^{(l'emphase est mienne)}

La chaîne vide split génère une largeur nulle match au début, alors une chaîne vide n'est pas incluse au début du tableau qui en résulte, conformément à ce qui est spécifié ci-dessus. En revanche, votre deuxième exemple qui se divise sur "a" génère un positif-largeur match au début de la chaîne, alors une chaîne vide est en fait incluse au début de la matrice résultante.

OriginalL'auteur arshajii