使用 Java 使用正则表达式查找更大字符串的子字符串

如果我有一个这样的字符串:

FOO[BAR]

我需要一种通用的方法来获取字符串中的“ BAR”字符串，这样不管方括号之间是什么字符串，它都能够获取字符串。

例如:。

FOO[DOG] = DOG
FOO[CAT] = CAT
375511 次浏览
小开
最佳答案

你应该能够使用非贪婪的量词，特别是 * ? 你可能需要以下内容:

Pattern MY_PATTERN = Pattern.compile("\\[(.*?)\\]");

这将为您提供一个匹配字符串的模式，并将文本放在第一组的方括号内。看一下 模式 API 文档了解更多信息。

要提取字符串，您可以使用如下代码:

Matcher m = MY_PATTERN.matcher("FOO[BAR]");
while (m.find()) {
String s = m.group(1);
// s now contains "BAR"
}
小开

非正则表达式:

String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf("["),input.indexOf("]"));

或者，为了稍微提高性能/内存使用率(感谢 Hosam) :

String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf('['),input.lastIndexOf(']'));
小开

我觉得你的正则表达式应该是这样的:

/FOO\[(.+)\]/

假设 FOO 是常数。

把这个放到 Java 里:

Pattern p = Pattern.compile("FOO\\[(.+)\\]");
Matcher m = p.matcher(inputLine);
小开

假设不允许在/FOO [([ ^ ]] *)]/中使用其他结束方括号

小开

我将定义在 [和 ]之间需要最大数量的非]字符。这些需要用反斜杠转义(在 Java 中，这些需要再次转义) ，non 的定义是一个字符类，因此在 [和 ](即 [^\\]])中。结果是:

FOO\\[([^\\]]+)\\]
小开

如果你只是需要得到 []之间的任何东西，你可以像这样使用 \[([^\]]*)\]:

Pattern regex = Pattern.compile("\\[([^\\]]*)\\]");
Matcher m = regex.matcher(str);
if (m.find()) {
result = m.group();
}

如果需要采用 identifier + [ + content + ]格式，那么只有当标识符为字母数字时，才可以限制提取内容:

[a-zA-Z][a-z-A-Z0-9_]*\s*\[([^\]]*)\]

这将验证诸如 Foo [Bar]或 myDevice_123["input"]之类的东西。

主要问题

主要的问题是当您想要提取类似下面这样的内容时:

FOO[BAR[CAT[123]]+DOG[FOO]]

正则表达式不工作，将返回 BAR[CAT[123和 FOO。
如果我们将正则表达式改为 \[(.*)\]，那么就可以了，但是，如果您试图从更复杂的内容中提取内容，比如:

FOO[BAR[CAT[123]]+DOG[FOO]] = myOtherFoo[BAR[5]]

没有一个正则表达式是有效的。

在所有情况下提取适当内容的最准确的正则表达式要复杂得多，因为它需要平衡 []对并提供它们的内容。

更简单的解决办法

如果您的问题变得复杂，而且 []的内容是任意的，那么您可以改为平衡 []对，并使用普通的旧代码而不是正则表达式提取字符串:

int i;
int brackets = 0;
string c;
result = "";
for (i = input.indexOf("["); i < str.length; i++) {
c = str.substring(i, i + 1);
if (c == '[') {
brackets++;
} else if (c == ']') {
brackets--;
if (brackets <= 0)
break;
}
result = result + c;
}

这是比实际代码更多的伪代码，我不是一个 Java 编码器，所以我不知道语法是否正确，但它应该很容易改进。
重要的是，这段代码应该可以工作，并允许您提取 []的内容，不管它有多复杂。

小开 
String input = "FOO[BAR]";
String result = input.substring(input.indexOf("[")+1,input.lastIndexOf("]"));

这将返回第一个“[’和最后一个“]”之间的值

Foo [ Bar ] = > Bar

Foo [ Bar [ test ]] = > Bar [ test ]

注意: 如果输入字符串格式不正确，应该添加错误检查。

小开

这是一个很好的例子:

Java

package org.regexp.replace;


import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class RegexpExample
{
public static void main(String[] args)
{
String string = "var1[value1], var2[value2], var3[value3]";
Pattern pattern = Pattern.compile("(\\[)(.*?)(\\])");
Matcher matcher = pattern.matcher(string);


List<String> listMatches = new ArrayList<String>();


while(matcher.find())
{
listMatches.add(matcher.group(2));
}


for(String s : listMatches)
{
System.out.println(s);
}
}
}

它显示:

value1
value2
value3
小开

如果您想解析来自 mYearInDB.toString () = [2013]的字符串，它会给出2013

Matcher n = MY_PATTERN.matcher("FOO[BAR]"+mYearInDB.toString());
while (n.find()) {
extracredYear  = n.group(1);
// s now contains "BAR"
}
System.out.println("Extrated output is : "+extracredYear);
小开 
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public static String get_match(String s, String p) {
// returns first match of p in s for first group in regular expression
Matcher m = Pattern.compile(p).matcher(s);
return m.find() ? m.group(1) : "";
}


get_match("FOO[BAR]", "\\[(.*?)\\]")  // returns "BAR"


public static List<String> get_matches(String s, String p) {
// returns all matches of p in s for first group in regular expression
List<String> matches = new ArrayList<String>();
Matcher m = Pattern.compile(p).matcher(s);
while(m.find()) {
matches.add(m.group(1));
}
return matches;
}


get_matches("FOO[BAR] FOO[CAT]", "\\[(.*?)\\]")) // returns [BAR, CAT]
小开 
"FOO[DOG]".replaceAll("^.*?\\[|\\].*", "");

这将返回一个字符串 只取方括号内的字符串。

这将删除方括号外的所有字符串。

您可以在线测试这个 java 示例代码: Http://tpcg.io/wzofu0

您可以从这里测试这个 regex: Https://regex101.com/r/ouazss/1


提交答案