Java:分隔逗号分隔的字符串，但忽略引号中的逗号

小开

最佳答案

试一试:

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

结果和第一个例子一样。

编辑

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

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

小开

我会这样做:

boolean foundQuote = false;


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


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


else


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

小开

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

https://github.com/pupi1985/JavaCSV-Reloaded (前一个库的分支，它将允许生成的输出在不运行Windows时具有Windows行结束符\r\n)

http://opencsv.sourceforge.net/

CSV API for Java

你能推荐一个Java库读取(可能写入)CSV文件吗?< / >

Java库或应用程序转换CSV到XML文件?< / >

小开

与其使用超前和其他疯狂的正则表达式，不如先取出引号。也就是说，对于每个引号分组，将该分组替换为__IDENTIFIER_1或其他指示符，并将该分组映射为string,string的映射。

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

小开

尝试(?!\"),(?!\")这样的看看。这应该匹配没有被"包围的,。

小开

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

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

小开

我没有耐心，没有选择等待答案。作为参考，它看起来并不难做这样的事情(这适用于我的应用程序，我不需要担心转义引号，因为引号中的东西仅限于几个约束形式):

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

(读者练习:也可以通过寻找反斜杠来处理转义引号。)

小开

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

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

小开

我不建议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是为了提高速度，而线程安全是无关紧要的。

小开

最简单的方法是不匹配分隔符，即逗号，使用复杂的附加逻辑来匹配实际需要的内容(可能是带引号的字符串的数据)，只是为了排除错误的分隔符，而是首先匹配所需的数据。

该模式由两个选项组成，一个带引号的字符串("[^"]*"或".*?")或下一个逗号之前的所有内容([^,]+)。为了支持空单元格，我们必须允许未加引号的项为空，并使用下一个逗号(如果有的话)，并使用\\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((\"(.*?)\"|[^,])*),?");

但是，字符串以引号形式保存。

小开

使用String.split()的一行程序怎么样?

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

小开

正则表达式不能处理转义字符。对于我的应用程序，我需要能够转义引号和空格(分隔符是空格，但代码是相同的)。

以下是我在Kotlin(来自这个特定应用程序的语言)中的解决方案，基于Fabian Steeg的解决方案:

fun parseString(input: String): List<String> {
val result = mutableListOf<String>()
var inQuotes = false
var inEscape = false
val current = StringBuilder()
for (i in input.indices) {
// If this character is escaped, add it without looking
if (inEscape) {
inEscape = false
current.append(input[i])
continue
}
when (val c = input[i]) {
'\\' -> inEscape = true // escape the next character, \ isn't added to result
',' -> if (inQuotes) {
current.append(c)
} else {
result += current.toString()
current.clear()
}
'"' -> inQuotes = !inQuotes
else -> current.append(c)
}
}
if (current.isNotEmpty()) {
result += current.toString()
}
return result
}

我认为这不是一个使用正则表达式的地方。与其他观点相反，我不认为解析器是多余的。它大约有20行，并且相当容易测试。