与this相关的问题
我有一个字符串
a\;b\\;c;d
在Java中看起来像
String s = "a\\;b\\\\;c;d"
我需要用分号按照以下规则进行分割：
如果分号前面有反斜杠，则不应将其视为分隔符（在 a 和 b 之间）。
如果反斜杠本身被转义，因此不转义分号，该分号应该是分隔符（在 b 和 c 之间）。
因此，如果分号前面有零个或偶数个反斜杠，则应将分号视为分隔符。
例如上面，我想得到以下字符串（java编译器的双反斜杠）：
a\;b\\
c
d
【问题讨论】：
标签： java regex escaping backslash
你可以使用正则表达式
(?:\\.|[^;\\]++)*
匹配非转义分号之间的所有文本：
List<String> matchList = new ArrayList<String>();
try {
Pattern regex = Pattern.compile("(?:\\\\.|[^;\\\\]++)*");
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
matchList.add(regexMatcher.group());
}
说明：
(?: # Match either...
\\. # any escaped character
| # or...
[^;\\]++ # any character(s) except semicolon or backslash; possessive match
)* # Repeat any number of times.
所有格匹配 (++) 对于避免由于嵌套量词而导致的灾难性回溯非常重要。
【讨论】：
[a\;b\\, , c, , d, ]。除了检查 group() 的返回值之外，是否有可能以某种方式阻止它？
* 更改为+，但是您也不会像a;;b 那样得到“真正的”空匹配。
"(?:\\\\(.|$)|[^;\\\\]++)*"，但不确定是否会创建另一个。我的表达（到目前为止）也解决了假空字段但保留真正的空字段是"(?<=(?:^|;))(?:\\\\(?:.|$)|[^;\\\\]++)*"。谢谢你的好主意。
String[] splitArray = subjectString.split("(?<!(?<!\\\\)\\\\);");
这应该可行。
解释：
// (?<!(?<!\\)\\);
//
// Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!(?<!\\)\\)»
// Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!\\)»
// Match the character “\” literally «\\»
// Match the character “\” literally «\\»
// Match the character “;” literally «;»
因此，您只需匹配前面没有正好一个 \ 的分号。
编辑：
String[] splitArray = subjectString.split("(?<!(?<!\\\\(\\\\\\\\){0,2000000})\\\\);");
这将处理任何奇数个 .如果您有超过 4000000 个 \，它当然会失败。编辑答案的解释：
// (?<!(?<!\\(\\\\){0,2000000})\\);
//
// Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!(?<!\\(\\\\){0,2000000})\\)»
// Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!\\(\\\\){0,2000000})»
// Match the character “\” literally «\\»
// Match the regular expression below and capture its match into backreference number 1 «(\\\\){0,2000000}»
// Between zero and 2000000 times, as many times as possible, giving back as needed (greedy) «{0,2000000}»
// Note: You repeated the capturing group itself. The group will capture only the last iteration. Put a capturing group around the repeated group to capture all iterations. «{0,2000000}»
// Match the character “\” literally «\\»
// Match the character “\” literally «\\»
// Match the character “\” literally «\\»
// Match the character “;” literally «;»
【讨论】：
a\\\;b;c 和其他带有两个以上反斜杠的情况会失败。
{0,many} hack 是不可信的，因为 Java 的可变宽度后向支持是出了名的错误。但即使在 .NET 中我也不会使用这种方法，因为它对后视完全没有任何限制。像 Tim 的正匹配方法更易读、更可靠、更便携（所有格量词不是必需的）。
我不相信用任何正则表达式来检测这些情况。我通常会为这些事情做一个简单的循环，我会使用C 来绘制它，因为它是很久以前我最后一次接触Java ;-)
int i, len, state;
char c;
for (len=myString.size(), state=0, i=0; i < len; i++) {
c=myString[i];
if (state == 0) {
if (c == '\\') {
state++;
} else if (c == ';') {
printf("; at offset %d", i);
}
} else {
state--;
}
}
优点是：
【讨论】：
此方法假定您的字符串中不会包含char '\0'。如果这样做，您可以使用其他字符。
public static String[] split(String s) {
String[] result = s.replaceAll("([^\\\\])\\\\;", "$1\0").split(";");
for (int i = 0; i < result.length; i++) {
result[i] = result[i].replaceAll("\0", "\\\\;");
}
return result;
}
【讨论】：
这是我认为的真正答案。
在我的情况下，我尝试使用 | 进行拆分，转义字符是 &。
final String regx = "(?<!((?:[^&]|^)(&&){0,10000}&))\\|";
String[] res = "&|aa|aa|&|&&&|&&|s||||e|".split(regx);
System.out.println(Arrays.toString(res));
在这段代码中，我使用 Lookbehind 来转义 & 字符。 注意后面的look必须有最大长度。
(?<!((?:[^&]|^)(&&){0,10000}&))\\|
这表示任何|，除了((?:[^&]|^)(&&){0,10000}&)) 之后的那些，这部分表示任何奇数个&s。
(?:[^&]|^) 部分很重要，以确保您将 | 后面的所有 &s 计数到开头或其他一些字符。
【讨论】：