Java : diviser une chaîne de caractères séparée par des virgules tout en ignorant les virgules entre guillemets

Question

J'ai une chaîne vaguement similaire à ceci :

foo,bar,c;qual="baz,blurb",d;junk="quux,syzygy"

que je veux diviser par des virgules -- mais je dois ignorer les virgules entre guillemets. Comment puis-je faire cela ? Il semble qu'une approche avec les regex échoue ; je suppose que je peux analyser manuellement et passer dans un mode différent lorsque je vois des guillemets, mais ce serait bien d'utiliser des bibliothèques préexistantes. (éditer : je suppose que je voulais dire des bibliothèques qui font déjà partie du JDK ou de bibliothèques couramment utilisées comme Apache Commons.)

la chaîne ci-dessus devrait être divisée en :

foo
bar
c;qual="baz,blurb"
d;junk="quux,syzygy"

note : ce n'est PAS un fichier CSV, c'est une seule chaîne contenue dans un fichier avec une structure globale plus grande

Answer 1

Essayer :

public class Main { 
    public static void main(String[] args) {
        String line = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\"";
        String[] tokens = line.split(",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)", -1);
        for(String t : tokens) {
            System.out.println("> "+t);
        }
    }
}

Sortie :

> foo
> bar
> c;qual="baz,blurb"
> d;junk="quux,syzygy"

En d'autres termes : séparez la virgule uniquement si cette virgule a zéro, ou un nombre pair de guillemets devant elle.

Ou, un peu plus convivial pour les yeux :

public class Main { 
    public static void main(String[] args) {
        String line = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\"";

        String otherThanQuote = " [^\"] ";
        String quotedString = String.format(" \" %s* \" ", otherThanQuote);
        String regex = String.format("(?x) "+ // activer les commentaires, ignorer les espaces blancs
                ",                         "+ // correspondre à une virgule
                "(?=                       "+ // commencer une recherche positive en avant
                "  (?:                     "+ //   démarrer le groupe non-capturant 1
                "    %s*                   "+ //     correspondre à 'otherThanQuote' zéro ou plusieurs fois
                "    %s                    "+ //     correspondre à 'quotedString'
                "  )*                      "+ //   fin du groupe 1 et le répéter zéro ou plusieurs fois
                "  %s*                     "+ //   correspondre à 'otherThanQuote'
                "  $                       "+ // correspondre à la fin de la chaîne
                ")                         ", // arrêter la recherche positive en avant
                otherThanQuote, quotedString, otherThanQuote);

        String[] tokens = line.split(regex, -1);
        for(String t : tokens) {
            System.out.println("> "+t);
        }
    }
}

qui produit le même résultat que le premier exemple.

ÉDITER

Comme mentionné par @MikeFHay dans les commentaires :

Je préfère utiliser Guava's Splitter, car il a des valeurs par défaut plus raisonnables (voir la discussion ci-dessus sur les correspondances vides étant supprimées par String#split()), donc j'ai fait :

Splitter.on(Pattern.compile(",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)"))

Answer 2

Alors que j'aime en général les expressions régulières, pour ce type de tokenisation dépendante de l'état, je crois qu'un simple analyseur (qui dans ce cas est beaucoup plus simple que ce que ce mot pourrait laisser penser) est probablement une solution plus propre, en particulier en ce qui concerne la maintenabilité, par exemple :

String input = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\"";
List result = new ArrayList();
int start = 0;
boolean inQuotes = false;
for (int current = 0; current < input.length(); current++) {
    if (input.charAt(current) == '\"') inQuotes = !inQuotes; // basculer l'état
    else if (input.charAt(current) == ',' && !inQuotes) {
        result.add(input.substring(start, current));
        start = current + 1;
    }
}
result.add(input.substring(start));

Si vous ne vous souciez pas de conserver les virgules à l'intérieur des guillemets, vous pourriez simplifier cette approche (pas de gestion de l'index de début, pas de cas spécial du dernier caractère) en remplaçant les virgules entre guillemets par autre chose puis en séparant au niveau des virgules :

String input = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\"";
StringBuilder builder = new StringBuilder(input);
boolean inQuotes = false;
for (int currentIndex = 0; currentIndex < builder.length(); currentIndex++) {
    char currentChar = builder.charAt(currentIndex);
    if (currentChar == '\"') inQuotes = !inQuotes; // basculer l'état
    if (currentChar == ',' && inQuotes) {
        builder.setCharAt(currentIndex, ';'); // ou '♡', et remplacer plus tard
    }
}
List result = Arrays.asList(builder.toString().split(","));

Answer 3

http://sourceforge.net/projects/javacsv/

https://github.com/pupi1985/JavaCSV-Reloaded (fork de la bibliothèque précédente qui permettra à la sortie générée d'avoir des terminaisons de ligne Windows \r\n lorsqu'elle n'est pas exécutée sur Windows)

http://opencsv.sourceforge.net/

API CSV pour Java

Pouvez-vous recommander une bibliothèque Java pour lire (et éventuellement écrire) des fichiers CSV ?

Bibliothèque Java ou application pour convertir un fichier CSV en fichier XML ?

Answer 4

Je ne conseillerais pas une réponse regex de Bart, je trouve la solution d'analyse meilleure dans ce cas particulier (comme Fabian l'a proposé). J'ai essayé la solution regex et ma propre implémentation d'analyse et j'ai trouvé que :

1. L'analyse est beaucoup plus rapide que le fractionnement avec regex avec des références arrière - environ 20 fois plus rapide pour les courtes chaînes, environ 40 fois plus rapide pour les longues chaînes.
2. Regex échoue à trouver une chaîne vide après la dernière virgule. Ce n'était cependant pas dans la question initiale, c'était ma requête.

Ma solution et test ci-dessous.

String tested = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\",";
long start = System.nanoTime();
String[] tokens = tested.split(",(?=([^\"]*\"[^\"]*\")*[^\"]*$)");
long timeWithSplitting = System.nanoTime() - start;

start = System.nanoTime(); 
List tokensList = new ArrayList();
boolean inQuotes = false;
StringBuilder b = new StringBuilder();
for (char c : tested.toCharArray()) {
    switch (c) {
    case ',':
        if (inQuotes) {
            b.append(c);
        } else {
            tokensList.add(b.toString());
            b = new StringBuilder();
        }
        break;
    case '\"':
        inQuotes = !inQuotes;
    default:
        b.append(c);
    break;
    }
}
tokensList.add(b.toString());
long timeWithParsing = System.nanoTime() - start;

System.out.println(Arrays.toString(tokens));
System.out.println(tokensList.toString());
System.out.printf("Time with splitting:\t%10d\n",timeWithSplitting);
System.out.printf("Time with parsing:\t%10d\n",timeWithParsing);

Bien sûr, vous êtes libre de changer le switch en else-ifs dans cet extrait si vous vous sentez mal à l'aise avec sa laideur. Notez alors l'absence de break après le switch avec le séparateur. StringBuilder a été choisi à la place de StringBuffer par conception pour augmenter la vitesse, où la sécurité des threads est sans importance.

Answer 5

Vous êtes dans cette zone limite ennuyante où les expressions régulières ne fonctionneront presque pas (comme l'a souligné Bart, échapper aux guillemets rendrait la vie difficile), et pourtant un analyseur complet semble excessif.

Si vous êtes susceptible d'avoir besoin d'une plus grande complexité dans un avenir proche, je vous recommanderais de chercher une bibliothèque d'analyseurs. Par exemple celui-ci