Java: suddivisione di una stringa separata da virgola ma ignorando le virgole tra virgolette

Ho una stringa vagamente simile a questa:

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

che voglio dividere per virgole, ma devo ignorare le virgolette tra virgolette. Come posso fare questo? Sembra un approccio regexp fallito; Suppongo di poter scansionare manualmente ed entrare in una modalità diversa quando vedo un preventivo, ma sarebbe bello usare librerie preesistenti. ( modifica : suppongo che intendessi librerie che fanno già parte del JDK o che fanno già parte di librerie di uso comune come Apache Commons.)

la stringa sopra dovrebbe essere divisa in:

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

nota: questo NON è un file CSV, è una singola stringa contenuta in un file con una struttura complessiva più ampia

Provare:

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

Produzione:

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

In altre parole: dividi la virgola solo se quella virgola ha zero o un numero pari di virgolette davanti a sé .

O, un po 'più amichevole per gli occhi:

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) "+ // enable comments, ignore white spaces
                ",                         "+ // match a comma
                "(?=                       "+ // start positive look ahead
                "  (?:                     "+ //   start non-capturing group 1
                "    %s*                   "+ //     match 'otherThanQuote' zero or more times
                "    %s                    "+ //     match 'quotedString'
                "  )*                      "+ //   end group 1 and repeat it zero or more times
                "  %s*                     "+ //   match 'otherThanQuote'
                "  $                       "+ // match the end of the string
                ")                         ", // stop positive look ahead
                otherThanQuote, quotedString, otherThanQuote);

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

che produce lo stesso del primo esempio.

MODIFICARE

Come menzionato da @MikeFHay nei commenti:

Preferisco usare Guava's Splitter , in quanto ha impostazioni predefinite più sanitarie (vedi la discussione sopra sulle partite vuote che vengono tagliate da String#split(), quindi ho fatto:

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

Mentre mi piacciono le espressioni regolari in generale, per questo tipo di tokenizzazione dipendente dallo stato credo che un semplice parser (che in questo caso è molto più semplice di quanto la parola possa far sembrare) sia probabilmente una soluzione più pulita, in particolare per quanto riguarda la manutenibilità , per esempio:

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

Se non ti interessa conservare le virgole all'interno delle virgolette, potresti semplificare questo approccio (nessuna gestione dell'indice iniziale, nessun caso speciale dell'ultimo carattere ) sostituendo le virgole tra virgolette con qualcos'altro e quindi dividere in virgole:

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; // toggle state
    if (currentChar == ',' && inQuotes) {
        builder.setCharAt(currentIndex, ';'); // or '♡', and replace later
    }
}
List<String> result = Arrays.asList(builder.toString().split(","));

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

https://github.com/pupi1985/JavaCSV-Reloaded (fork della libreria precedente che consentirà all'output generato di avere terminatori di linea di Windows \r\nquando non si esegue Windows)

http://opencsv.sourceforge.net/

API CSV per Java

Puoi consigliare una libreria Java per leggere (e possibilmente scrivere) file CSV?

Lib o app Java per convertire file CSV in XML?

Non consiglierei una risposta regex da Bart, trovo che la soluzione di analisi sia migliore in questo caso particolare (come proposto da Fabian). Ho provato la soluzione regex e la propria implementazione dell'analisi ho scoperto che:

1. L'analisi è molto più veloce della divisione con regex con riferimenti indietro - ~ 20 volte più veloce per stringhe brevi, ~ 40 volte più veloce per stringhe lunghe.
2. Regex non riesce a trovare una stringa vuota dopo l'ultima virgola. Questo non era nella domanda originale, era il mio requisito.

La mia soluzione e prova di seguito.

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<String> tokensList = new ArrayList<String>();
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);

Naturalmente sei libero di cambiare passaggio agli altri se in questo frammento se ti senti a disagio con la sua bruttezza. Nota quindi mancanza di interruzione dopo interruttore con separatore. StringBuilder è stato scelto invece da StringBuffer in base alla progettazione per aumentare la velocità, dove la sicurezza del thread è irrilevante.

Prova un lookaround come (?!\"),(?!\"). Questo dovrebbe corrispondere a ,quello che non è circondato ".

Sei in quella fastidiosa area di confine dove le regexps quasi non lo faranno (come è stato sottolineato da Bart, sfuggire alle virgolette renderebbe la vita difficile), eppure un parser in piena regola sembra eccessivo.

Se è probabile che tu abbia bisogno di maggiore complessità in qualsiasi momento, andrei a cercare una libreria di parser. Ad esempio questo

Ero impaziente e ho scelto di non aspettare le risposte ... per riferimento non sembra così difficile fare qualcosa del genere (che funziona per la mia applicazione, non ho bisogno di preoccuparmi delle virgolette sfuggite, come le cose tra virgolette è limitato a poche forme vincolate):

final static private Pattern splitSearchPattern = Pattern.compile("[\",]"); 
private List<String> splitByCommasNotInQuotes(String s) {
    if (s == null)
        return Collections.emptyList();

    List<String> list = new ArrayList<String>();
    Matcher m = splitSearchPattern.matcher(s);
    int pos = 0;
    boolean quoteMode = false;
    while (m.find())
    {
        String sep = m.group();
        if ("\"".equals(sep))
        {
            quoteMode = !quoteMode;
        }
        else if (!quoteMode && ",".equals(sep))
        {
            int toPos = m.start(); 
            list.add(s.substring(pos, toPos));
            pos = m.end();
        }
    }
    if (pos < s.length())
        list.add(s.substring(pos));
    return list;
}

(esercizio per il lettore: estendere alla gestione delle virgolette sfuggite cercando anche le barre rovesciate.)

L'approccio più semplice non è quello di abbinare i delimitatori, cioè le virgole, con una logica aggiuntiva complessa per abbinare ciò che è effettivamente inteso (i dati che potrebbero essere citati stringhe), solo per escludere falsi delimitatori, ma piuttosto abbinare i dati previsti in primo luogo.

Il modello è composto da due alternative, una stringa tra virgolette ( "[^"]*"o ".*?") o tutto fino alla virgola successiva ( [^,]+). Per supportare celle vuote, dobbiamo consentire che l'elemento non quotato sia vuoto e consumare la virgola successiva, se presente, e utilizzare l' \\Gancoraggio:

Pattern p = Pattern.compile("\\G\"(.*?)\",?|([^,]*),?");

Il modello contiene anche due gruppi di acquisizione per ottenere il contenuto della stringa tra virgolette o il contenuto normale.

Quindi, con Java 9, possiamo ottenere un array come

String[] a = p.matcher(input).results()
    .map(m -> m.group(m.start(1)<0? 2: 1))
    .toArray(String[]::new);

mentre le versioni precedenti di Java richiedono un ciclo simile

for(Matcher m = p.matcher(input); m.find(); ) {
    String token = m.group(m.start(1)<0? 2: 1);
    System.out.println("found: "+token);
}

Aggiunta degli elementi a List o una matrice viene lasciata come accisa al lettore.

Per Java 8, è possibile utilizzare l' results()implementazione di questa risposta , per farlo come la soluzione Java 9.

Per contenuti misti con stringhe incorporate, come nella domanda, puoi semplicemente usare

Pattern p = Pattern.compile("\\G((\"(.*?)\"|[^,])*),?");

Ma poi, le stringhe vengono mantenute nella loro forma quotata.

Invece di usare lookahead e altri regex pazzi, basta tirare fuori prima le virgolette. Cioè, per ogni raggruppamento di preventivi, sostituiscilo con__IDENTIFIER_1 o qualche altro indicatore e mappare quel raggruppamento su una mappa di stringa, stringa.

Dopo aver diviso la virgola, sostituire tutti gli identificatori mappati con i valori di stringa originali.

che dire di un one-liner usando String.split ()?

String s = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\"";
String[] split = s.split( "(?<!\".{0,255}[^\"]),|,(?![^\"].*\")" );

Vorrei fare qualcosa del genere:

boolean foundQuote = false;

if(charAtIndex(currentStringIndex) == '"')
{
   foundQuote = true;
}

if(foundQuote == true)
{
   //do nothing
}

else 

{
  string[] split = currentString.split(',');  
}