Java: разделение запятой строки, но игнорирование запятых в кавычках

249

У меня есть строка, примерно такая:

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

что я хочу разделить запятыми - но мне нужно игнорировать запятые в кавычках. Как я могу это сделать? Похоже, что регулярное выражение терпит неудачу; Я полагаю, что я могу вручную сканировать и переходить в другой режим, когда вижу цитату, но было бы неплохо использовать уже существующие библиотеки. ( отредактируйте : я предполагаю, что имел в виду библиотеки, которые уже являются частью JDK или уже являются частью широко используемых библиотек, таких как Apache Commons.)

вышеуказанная строка должна быть разбита на:

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

примечание: это НЕ файл CSV, это отдельная строка, содержащаяся в файле с большей общей структурой

Джейсон С
источник

Ответы:

435

Пытаться:

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

Вывод:

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

Другими словами: разделять запятую, только если эта запятая имеет ноль или четное число кавычек перед ней .

Или немного дружелюбнее для глаз:

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

который производит так же, как в первом примере.

РЕДАКТИРОВАТЬ

Как упомянуто @MikeFHay в комментариях:

Я предпочитаю использовать Splitter Guava , так как он имеет более разумные значения по умолчанию (см. Обсуждение выше об обрезании пустых совпадений String#split(), поэтому я сделал:

Splitter.on(Pattern.compile(",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)"))
Барт Киерс
источник
Согласно RFC 4180: Sec 2.6: «Поля, содержащие разрывы строк (CRLF), двойные кавычки и запятые, должны быть заключены в двойные кавычки». Раздел 2.7: «Если для заключения полей используются двойные кавычки, то двойная кавычка, появляющаяся внутри поля, должна быть экранирована, если ей предшествует еще одна двойная кавычка». Итак, если String line = "equals: =,\"quote: \"\"\",\"comma: ,\""все, что вам нужно, это удалить лишние двойные кавычки персонажи.
Пол Ханбери
@Bart: моя точка зрения заключается в том, что ваше решение все еще работает, даже со встроенными кавычками
Пол Ханбери
6
@Alex, да, запятая это соответствует, но пустой матч не в результате. Добавить -1в методе раздельных пары: line.split(regex, -1). См .: docs.oracle.com/javase/6/docs/api/java/lang/…
Барт Киерс,
2
Прекрасно работает! Я предпочитаю использовать Splitter Guava, так как он имеет более разумные значения по умолчанию (см. Обсуждение выше о пустых совпадениях, которые обрезаются с помощью String # split), поэтому я сделал это Splitter.on(Pattern.compile(",(?=([^\"]*\"[^\"]*\")*[^\"]*$)")).
MikeFHay
2
ПРЕДУПРЕЖДЕНИЕ!!!! Это регулярное выражение медленное !!! Он имеет O (N ^ 2) поведение в том смысле, что просмотр каждой запятой выглядит вплоть до конца строки. Использование этого регулярного выражения вызвало четырехкратное замедление в больших заданиях Spark (например, 45 минут -> 3 часа). Более быстрая альтернатива - это что-то вроде findAllIn("(?s)(?:\".*?\"|[^\",]*)*")в сочетании с шагом постобработки для пропуска первого (всегда пустого) поля после каждого непустого поля.
Городской бродяга
46

Хотя мне нравятся регулярные выражения в целом, для такого вида токенизации, зависящей от состояния, я считаю, что простой синтаксический анализатор (который в данном случае намного проще, чем это слово может сделать его звучащим), вероятно, является более чистым решением, особенно в том, что касается ремонтопригодности. Например:

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

Если вам не нужно сохранять запятые внутри кавычек, вы можете упростить этот подход (без обработки начального индекса, без особого случая последнего символа ), заменив запятые в кавычках чем-то другим, а затем разделив их запятыми:

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(","));
Фабиан Стиг
источник
Кавычки должны быть удалены из разбираемых токенов после разбора строки.
Судхир N
Нашел через гугл, хороший алгоритм, братан, просто и легко адаптировать, согласен. вещи с состоянием должны выполняться через парсер, регулярное выражение - беспорядок.
Рудольф Шмидт
2
Помните, что если запятая является последним символом, она будет указана в строковом значении последнего элемента.
Габриэль Гейтс
21

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

https://github.com/pupi1985/JavaCSV-Reloaded (ветвь предыдущей библиотеки, которая позволит сгенерированному выводу иметь разделители строк Windows, \r\nкогда Windows не работает)

http://opencsv.sourceforge.net/

CSV API для Java

Можете ли вы порекомендовать библиотеку Java для чтения (и, возможно, записи) файлов CSV?

Java lib или приложение для преобразования CSV в XML-файл?

Джонатан Фейнберг
источник
3
Хороший звонок, признающий, что OP анализировал файл CSV. Внешняя библиотека чрезвычайно подходит для этой задачи.
Стефан Кендалл
1
Но строка является строкой CSV; Вы должны быть в состоянии использовать API CSV для этой строки напрямую.
Майкл Брюер-Дэвис
да, но эта задача достаточно проста и представляет собой гораздо меньшую часть более крупного приложения, поэтому мне не хочется тянуть в другую внешнюю библиотеку.
Джейсон С
7
не обязательно ... мои навыки часто адекватны, но они выигрывают от оттачивания.
Джейсон С
9

Я бы не советовал ответить на регулярные выражения от Барта, я считаю, что в этом конкретном случае решение для разбора лучше (как предложил Фабиан). Я пробовал решение регулярных выражений и собственную реализацию синтаксического анализа, я обнаружил, что:

  1. Синтаксический анализ выполняется намного быстрее, чем разделение с помощью регулярных выражений с обратными ссылками - ~ в 20 раз быстрее для коротких строк, ~ в 40 раз быстрее для длинных строк.
  2. Regex не может найти пустую строку после последней запятой. Это не было в оригинальном вопросе, хотя, это было мое требование.

Мое решение и тест ниже.

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

Конечно, вы можете свободно переключаться на else-if в этом фрагменте, если чувствуете себя неловко из-за его уродства. Обратите внимание на отсутствие разрыва после переключения с разделителем. Вместо этого StringBuilder был выбран вместо StringBuffer для увеличения скорости, где безопасность потоков не имеет значения.

Марчин Косински
источник
2
Интересный момент относительно разделения времени против синтаксического анализа. Однако утверждение № 2 является неточным. Если вы добавите a -1в метод split в ответе Барта, вы поймаете пустые строки (включая пустые строки после последней запятой):line.split(regex, -1)
Peter
+1, потому что это лучшее решение проблемы, для которой я искал решение: анализ сложной строки параметра тела HTTP POST
varontron
2

Попробуйте выглядеть как (?!\"),(?!\"). Это должно соответствовать тому, ,что не окружено ".

Мэтью Соудерс
источник
Уверен, что это сломалось бы для такого списка, как: "foo", bar, "baz"
Angelo Genovese
1
Я думаю, что вы имели в виду (?<!"),(?!"), но это все равно не сработает. Учитывая строку one,two,"three,four", она правильно соответствует запятой в one,two, но она также совпадает с запятой в "three,four"и не совпадает с одной в two,"three.
Алан Мур
Это кажется мне идеальным, я думаю, что это лучший ответ, потому что он короче и легче для понимания
Ordiel
2

Вы находитесь в этой надоедливой граничной области, где регулярные выражения почти не подходят (как указывал Барт, выход из кавычек осложнил бы жизнь), и все же полноценный парсер кажется излишним.

Если вам, скорее всего, понадобится больше сложности в ближайшее время, я бы пошел искать библиотеку синтаксического анализатора. Например, этот

DJNA
источник
2

Я был нетерпелив и решил не ждать ответов ... для справки не выглядит так сложно сделать что-то подобное (что работает для моего приложения, мне не нужно беспокоиться о экранированных кавычках, так как материал в кавычках) ограничено несколькими ограниченными формами):

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

(упражнение для читателя: перейдите к обработке экранированных кавычек, ища также обратную косую черту.)

Джейсон С
источник
1

Простейший подход состоит не в том, чтобы сопоставлять разделители, то есть запятые, со сложной дополнительной логикой для сопоставления с тем, что на самом деле предназначено (данные, которые могут быть строками в кавычках), просто для исключения ложных разделителей, а скорее для сопоставления предполагаемых данных в первую очередь.

Шаблон состоит из двух альтернатив: строки в кавычках ( "[^"]*"или ".*?") или всего до следующей запятой ( [^,]+). Для поддержки пустых ячеек мы должны позволить пустому элементу без кавычек использовать следующую запятую, если она есть, и использовать \\Gпривязку:

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

Шаблон также содержит две группы захвата для получения: содержимое строки в кавычках или простое содержимое.

Затем, с Java 9, мы можем получить массив как

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

тогда как более старые версии Java нуждаются в цикле

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

Добавление элементов в Listмассив или массив остается акцизом для читателя.

Для Java 8 вы можете использовать results()реализацию этого ответа , чтобы сделать это подобно решению Java 9.

Для смешанного контента со встроенными строками, как в вопросе, вы можете просто использовать

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

Но затем строки хранятся в указанном виде.

Holger
источник
0

Вместо того, чтобы использовать lookahead и другие сумасшедшие регулярные выражения, сначала вытащите цитаты. То есть для каждой группировки цитат замените эту группировку __IDENTIFIER_1или каким-либо другим индикатором и сопоставьте эту группировку с картой строки, строки.

После разделения на запятую замените все сопоставленные идентификаторы исходными строковыми значениями.

Стефан Кендалл
источник
а как найти цитатные группировки без сумасшедших регулярных выражений?
Кай Хуппманн
Для каждого символа, если символ является кавычкой, найдите следующую кавычку и замените на группировку. Если нет следующей цитаты, сделано.
Стефан Кендалл
0

как насчет однострочника с использованием String.split ()?

String s = "foo,bar,c;qual=\"baz,blurb\",d;junk=\"quux,syzygy\"";
String[] split = s.split( "(?<!\".{0,255}[^\"]),|,(?![^\"].*\")" );
Каплан
источник
-1

Я бы сделал что-то вроде этого:

boolean foundQuote = false;

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

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

else 

{
  string[] split = currentString.split(',');  
}
Woot4Moo
источник