Question

我有一个模糊的字符串：

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

我想用逗号分隔 - 但我需要在引号中忽略逗号。我怎样才能做到这一点？看起来像正则表达式方法失败;我想我可以在看到引号时手动扫描并进入不同的模式，但是使用预先存在的库会更好。（编辑：我想我的意思是已经是JDK的一部分或已经是Apache Commons等常用库的一部分的库。）

上面的字符串应该分成：

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

注意：这不是CSV文件，它是包含在整体结构较大的文件中的单个字符串

Answer 1

尝试：

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在评论中提到的那样：

我更喜欢使用Guava's Splitter，因为它有更好的默认设置（请参阅上面关于String#split()修剪空匹配的讨论，所以我做了：
Splitter.on(Pattern.compile(",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)"))

Answer 2

虽然我确实喜欢正则表达式，但是对于这种依赖于状态的标记化，我相信一个简单的解析器（在这种情况下比这个单词要简单得多）可能是一个更清晰的解决方案，特别是关于可维护性，例如：

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(","));

Answer 3

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

https://github.com/pupi1985/JavaCSV-Reloaded （前一个库的fork，允许生成的输出在不运行Windows时具有Windows行终止符\r\n）

http://opencsv.sourceforge.net/

CSV API for Java

Can you recommend a Java library for reading (and possibly writing) CSV files?

Java lib or app to convert CSV to XML file?

Answer 4

我不会建议Bart的正则表达式答案，我发现在这种特殊情况下解析解决方案更好（正如Fabian提出的那样）。我已经尝试了正则表达式解决方案和自己的解析实现，我发现：

解析比使用反向引用正则表达式分裂快得多 - 短字符串快20倍，长字符串快〜40倍。
正则表达式在最后一个逗号后找不到空字符串。但这不是原始问题，这是我的要求。

我的解决方案和测试如下。

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-ifs。注意用分离器切换后没有断裂。 StringBuilder被设计为StringBuffer，以提高速度，线程安全性无关紧要。

Answer 5

尝试像(?!\"),(?!\")一样的lookaround。这应该与未被,包围的"匹配。

Answer 6

你正处于那个令人讨厌的边界区域，在那里regexps几乎不会做（正如Bart所指出的那样，逃避引用会让生活变得艰难），然而一个成熟的解析器似乎有点矫枉过正。

如果您可能需要更快的复杂性，我会去寻找解析器库。例如this one

Answer 7

我很不耐烦，选择不等待答案......作为参考，这样的事情看起来并不难（适用于我的应用程序，我不需要担心转义报价，因为引号中的内容仅限于一些约束形式）：

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

（读者练习：通过查找反斜杠扩展到处理转义引号。）

Answer 8

不要使用前瞻和其他疯狂的正则表达式，而是先拔出引号。也就是说，对于每个引用分组，将该分组替换为__IDENTIFIER_1或其他指示符，并将该分组映射到字符串，字符串的映射。

在逗号分割后，将所有映射的标识符替换为原始字符串值。

Answer 9

最简单的方法是不使用复杂的附加逻辑来匹配定界符（即逗号），以匹配实际的意图（可能用引号引起来的数据），而只是排除错误的定界符，而是匹配定界符中的预期数据。第一名。

该模式由两个选项组成，一个带引号的字符串（"[^"]*"或".*?"）或下一个逗号之前的所有内容（[^,]+）。为了支持空单元格，我们必须允许未引用的项目为空，并使用下一个逗号（如果有的话），并使用\\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，您可以使用this answer的results()实现，就像Java 9解决方案一样。

对于带有嵌入字符串的混合内容，例如在问题中，您可以简单地使用

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

但是，这些字符串将保留其引号形式。

Answer 10

使用String.split（）的单线笔是什么？

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

Answer 11

我会做这样的事情：

boolean foundQuote = false;

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

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

else 

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

Java：拆分以逗号分隔的字符串，但忽略引号中的逗号

11 个答案:

修改