le comportement de String.split (qui appelle Pattern.split ) change entre Java 7 et Java 8.

Documentation

comparant la documentation de Pattern.split dans Java 7 et Java 8 , nous observons que la clause suivante est ajoutée:

Lorsqu'il y a une correspondance positive-width au début de la séquence d'entrée, puis une correspondance vide la sous-couche principale est incluse au début du tableau résultant. Une correspondance zéro-Largeur au début ne produit cependant jamais une telle sous-couche vide.

la même clause est également ajoutée à String.split dans Java 8 , comparé à Java 7 .

implémentation de Référence

comparons le code de Pattern.split de l'implémentation de référence en Java 7 et Java 8. Le code est récupéré à partir du grepcode, pour les versions 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 suivant en Java 8 exclut la correspondance de longueur zéro au début de la chaîne de saisie, 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;
            }

maintien de la compatibilité

suit le comportement en Java 8 et au-dessus

pour faire split se comporte de manière cohérente à travers les versions et compatible avec le comportement en Java 8:

1. si votre regex peut correspond à la chaîne de longueur zéro, il suffit d'ajouter (?!\A) à la fin du regex et envelopper le regex original dans le groupe de non-capture (?:...) (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 le regex peut correspondre à la chaîne de longueur zéro ou non, faites les deux actions à l'étape 1.

(?!\A) vérifie que la chaîne ne se termine pas au début de la chaîne, ce qui implique que la correspondance est une correspondance vide au début de la chaîne.

comportement suivant en Java 7 et avant

il n'y a pas solution générale pour rendre split rétro-compatible avec Java 7 et prior, sauf pour remplacer toutes les instances de split pour pointer vers votre propre implémentation personnalisée.