Java: dzielenie łańcucha rozdzielanego przecinkami, ale ignorowanie przecinków w cudzysłowach

Mam ciąg niejasno taki:

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

że chcę podzielić przecinki - ale muszę zignorować przecinki w cudzysłowie. W jaki sposób mogę to zrobić? Wydaje się, że podejście wyrażenia regularnego kończy się niepowodzeniem; Przypuszczam, że mogę ręcznie zeskanować i przejść do innego trybu, gdy zobaczę cytat, ale dobrze byłoby użyć wcześniej istniejących bibliotek. ( edycja : Myślę, że miałem na myśli biblioteki, które są już częścią JDK lub już są częścią powszechnie używanych bibliotek, takich jak Apache Commons.)

powyższy ciąg powinien zostać podzielony na:

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

Uwaga: to NIE jest plik CSV, to pojedynczy ciąg znaków zawarty w pliku o większej ogólnej strukturze

Próbować:

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

Wynik:

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

Innymi słowy: podziel przecinek tylko wtedy, gdy przecinek ten ma zero lub parzystą liczbę cudzysłowów przed nim .

Lub nieco bardziej przyjazny dla oczu:

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

co daje taki sam jak pierwszy przykład.

EDYTOWAĆ

Jak wspomniano w @MikeFHay w komentarzach:

Wolę używać rozgałęziacza Guavy , ponieważ ma on domyślne ustawienia (patrz dyskusja powyżej na temat przycinania pustych dopasowań String#split(), więc zrobiłem:

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

Chociaż ogólnie lubię wyrażenia regularne, dla tego rodzaju tokenizacji zależnej od stanu uważam, że prosty parser (który w tym przypadku jest znacznie prostszy niż to słowo mogłoby zabrzmieć) jest prawdopodobnie czystszym rozwiązaniem, w szczególności w odniesieniu do łatwości konserwacji , np .:

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

Jeśli nie zależy ci na zachowaniu przecinków w cudzysłowie, możesz uprościć to podejście (bez obsługi indeksu początkowego, żadnego specjalnego przypadku ostatniego znaku ), zastępując przecinki w cudzysłowach czymś innym, a następnie rozdzielając je przecinkami:

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 (rozwidlenie poprzedniej biblioteki, która pozwoli generowanym wyjściom na zakończenie linii Windows, \r\ngdy nie jest uruchomiony Windows)

http://opencsv.sourceforge.net/

CSV API dla Java

Czy możesz polecić bibliotekę Java do odczytu (i ewentualnie zapisu) plików CSV?

Lib Java lub aplikacja do konwersji CSV do pliku XML?

Nie zalecałbym odpowiedzi Bartka, w tym konkretnym przypadku znajduję lepsze rozwiązanie do analizowania (jak zaproponował Fabian). Próbowałem rozwiązania regex i własnej implementacji parsowania. Odkryłem, że:

1. Analiza jest znacznie szybsza niż dzielenie za pomocą wyrażeń regularnych z referencjami wstecznymi - ~ 20 razy szybciej dla krótkich łańcuchów, ~ 40 razy szybciej dla długich łańcuchów.
2. Regex nie może znaleźć pustego ciągu po ostatnim przecinku. To nie było pierwotne pytanie, to był mój wymóg.

Moje rozwiązanie i test poniżej.

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

Oczywiście możesz swobodnie zmienić w tym fragmencie przejście na „else-ifs”, jeśli czujesz się niekomfortowo z powodu jego brzydoty. Zwróć uwagę na brak przerwy po przełączniku z separatorem. Zamiast tego StringBuilder został wybrany na StringBuffer, aby zwiększyć prędkość, w której bezpieczeństwo wątków jest nieistotne.

Spróbuj spojrzeć jak (?!\"),(?!\"). To powinno pasować ,, które nie są otoczone ".

Znajdujesz się w irytującym obszarze granicznym, w którym wyrażenia regularne prawie nie wystarczą (jak zauważył Bart, unikanie cytatów utrudniłoby życie), a jednak pełny parser wydaje się przesadą.

Jeśli w najbliższym czasie będziesz potrzebować większej złożoności, poszukałbym biblioteki parserów. Na przykład ten

Byłem niecierpliwy i postanowiłem nie czekać na odpowiedzi ... w celach informacyjnych nie wydaje się to tak trudne, aby zrobić coś takiego (co działa w mojej aplikacji, nie muszę się martwić o ucieczkę cytatów, ponieważ to w cytatach jest ograniczony do kilku form ograniczonych):

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

(ćwiczenie dla czytelnika: rozciągnij się na obsługę cytowanych cytatów poprzez wyszukiwanie odwrotnych ukośników).

Najprostszym podejściem nie jest dopasowanie ograniczników, tj. Przecinków, ze złożoną dodatkową logiką, aby dopasować to, co jest rzeczywiście zamierzone (dane, które mogą być ciągami cytowanymi), aby wykluczyć fałszywe ograniczniki, ale raczej dopasować zamierzone dane w pierwszej kolejności.

Wzór składa się z dwóch alternatyw, cytowanego ciągu ( "[^"]*"lub ".*?") lub wszystkiego do następnego przecinka ( [^,]+). Aby wesprzeć puste komórki, musimy pozwolić, aby niecytowany element był pusty i zużyć następny przecinek, jeśli taki istnieje, i użyć \\Gkotwicy:

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

Wzorzec zawiera również dwie grupy przechwytywania, aby uzyskać albo treść cytowanego ciągu, albo zwykłą treść.

Następnie, w Javie 9, możemy uzyskać tablicę jako

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

podczas gdy starsze wersje Java wymagają pętli

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

Dodanie elementów do Listtablicy lub tablicy pozostawia czytelnikowi akcyzę.

W przypadku języka Java 8 można użyć results()implementacji tej odpowiedzi , aby zrobić to jak rozwiązanie Java 9.

W przypadku zawartości mieszanej z osadzonymi ciągami, jak w pytaniu, możesz po prostu użyć

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

Ale potem ciągi są przechowywane w ich cytowanej formie.

Zamiast używać lookahead i innych zwariowanych wyrażeń regularnych, najpierw wyciągnij cytaty. Oznacza to, że dla każdej grupy cytatów zamień tę grupę na __IDENTIFIER_1inny lub inny wskaźnik i zamapuj tę grupę na mapę ciągu znaków.

Po podzieleniu przecinkiem zamień wszystkie zamapowane identyfikatory na oryginalne wartości ciągu.

co z linią jednowierszową za pomocą String.split ()?

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

Zrobiłbym coś takiego:

boolean foundQuote = false;

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

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

else 

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