虽然我一般喜欢正则表达式，但对于这种依赖于状态的标记化，我相信一个简单的解析器(在这种情况下，它比这个词听起来要简单得多)可能是一个更干净的解决方案，特别是在可维护性方面，例如:

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
    else if (input.charAt(current) == ',' && !inQuotes) {
        result.add(input.substring(start, current));
        start = current + 1;
    }
}
result.add(input.substring(start));

如果你不关心保留引号内的逗号，你可以简化这种方法(不处理开始索引，没有最后一个字符的特殊情况)，用其他东西替换引号中的逗号，然后以逗号分隔:

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

您正处于一个恼人的边界区域，regexp几乎不起作用(正如Bart所指出的，转义引号会使生活变得困难)，然而一个成熟的解析器似乎有点过头了。

如果您可能需要更大的复杂性，我会去寻找一个解析器库。比如这个

Try:

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"

换句话说:仅当逗号前面有0个引号或偶数个引号时，才在逗号上进行分隔。

或者，对眼睛更友好一点:

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

结果和第一个例子一样。

EDIT

正如@MikeFHay在评论中提到的:

我更喜欢使用Guava的Splitter，因为它有更理智的默认值(见上面关于空匹配被String#split()修剪的讨论，所以我这样做了: Splitter.on (Pattern.compile (",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)"))

我会这样做:

boolean foundQuote = false;

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

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

else 

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

试着看看(?!\")，(?!\")。这应该是相匹配的，那是不被包围的。

我不建议Bart给出正则表达式的答案，我发现在这种特殊情况下解析解决方案更好(就像Fabian提出的那样)。我已经尝试过正则表达式解决方案和自己的解析实现，我发现:

解析比使用带反向引用的regex进行拆分要快得多——短字符串快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-if。注意在使用分离器开关后没有中断。选择StringBuilder代替StringBuffer是为了提高速度，而线程安全是无关紧要的。