Question

我有一个包含多个子字符串的字符串，必须将其解压缩。将被提取的字符串在'字符之间。

当我使用indexOf或regex时，我只能提取第一个或最后一个。

如何解析它们并将它们放入数组或列表中而不解析相同的字符串？

resultData = "Error 205: 'x' data is not crawled yet. Check 'y' and 'z' data and update dataset 't'";

我在下面试过了;

protected static String errorsTPrinted(String errStr, int errCode) { 

if (errCode== 202 ) {

ArrayList<String> ar = new ArrayList<String>();
Pattern p = Pattern.compile("'(.*?)'");
Matcher m = p.matcher(errStr);
String text;

for (int i = 0; i < errStr.length(); i++) {

m.find();
text = m.group(1);
ar.add(text);
}

return errStr = "Err 202: " + ar.get(0) + " ... " + ar.get(1) + " ..." + ar.get(2) + " ... " + ar.get(3);
}

修改

我使用了@MinecraftShamrock的方法。

if (errCode== 202 ) {
List<String> getQuotet = getQuotet(errStr, '\'');
return errStr = "Err 202: " + getQuotet.get(0) + " ... " + getQuotet.get(1) + " ..." + getQuotet.get(2) + " ... " + getQuotet.get(3);
}

Answer 1

只需使用模式：

'([^']++)'

和Matcher一样：

final Pattern pattern = Pattern.compile("'([^']++)'");
final Matcher matcher = pattern.matcher(resultData);
while (matcher.find()) {
    System.out.println(matcher.group(1));
}

这将遍历String中的每个匹配并打印出来。

输出：

x
y
z
t

Answer 2

这是一个简单的方法（假设没有转义字符等）：

// Compile a pattern to find the wanted strings
Pattern p = Pattern.compile("'([^']+)'");
// Create a matcher for given input
Matcher m = p.matcher(resultData);
// A list to put the found strings into
List<String> list = new ArrayList<String>();
// Loop over all occurrences
while(m.find()) {
  // Retrieve the matched text
  String text = m.group(1);
  // Do something with the text, e.g. add it to a List
  list.add(text);
}

Answer 3

您可以使用这种非常简单的算法来避免正则表达式（因为人们无法100％确定其复杂性）：

public List<String> getQuotet(final String input, final char quote) {
    final ArrayList<String> result = new ArrayList<>();
    int n = -1;
    for(int i = 0; i < input.length(); i++) {
        if(input.charAt(i) == quote) {
            if(n == -1) { //not currently inside quote -> start new quote
                n = i + 1;
            } else { //close current quote
                result.add(input.substring(n, i));
                n = -1;
            }
        }
    }
    return result;
}

这适用于任何所需的引号字符，运行时复杂度为O（n）。如果字符串以开放引号结尾，则不会包含该字符串。但是，这可以很容易地添加。

我认为这比正则表达式更可取，因为你可以绝对肯定它的复杂性。此外，它适用于最少的库类。如果你关心大输入的效率，请使用它。

最后但并非最不重要的是，它绝对不关心两个引号字符之间的内容，因此它适用于任何输入字符串。

如何在Java中提取多引号子串

3 个答案: