Question

试图制作一个正则表达式，抓住所有单词，比如说，鸡，不在括号中。所以喜欢

chicken

会被选中但是

[chicken]

不会。有谁知道怎么做？

Answer 1

String template = "[chicken]";
String pattern = "\\G(?<!\\[)(\\w+)(?!\\])";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(template);

while (m.find()) 
{
     System.out.println(m.group());
}

它使用negative look-behind and negative look-aheads和boundary matchers的组合。

(?<!\\[) //negative look behind
(?!\\])  //negative look ahead
(\\w+)   //capture group for the word
\\G      //is a boundary matcher for marking the end of the previous match

（请阅读以下编辑内容以澄清）

编辑1：
如果需要考虑以下情况：

"chicken [chicken] chicken [chicken]"

我们可以用以下代码替换正则表达式：

String regex = "(?<!\\[)\\b(\\w+)\\b(?!\\])";

编辑2：
如果还需要考虑以下情况：

"[chicken"
"chicken]"

如同一个人仍然需要"chicken"，那么你可以使用：

String pattern = "(?<!\\[)?\\b(\\w+)\\b(?!\\])|(?<!\\[)\\b(\\w+)\\b(?!\\])?";

这基本上解释了两侧只有一个支架的两种情况。它通过|完成此操作，?充当or，并在前瞻/后方之后使用?，其中{{1}}表示前一个表达式的0或1。

Answer 2

我想你想要这样的东西：

final Pattern UNBRACKETED_WORD_PAT = Pattern.compile("(?<!\\[)\\b\\w+\\b(?!])");

private List<String> findAllUnbracketedWords(final String s) {
    final List<String> ret = new ArrayList<String>();
    final Matcher m = UNBRACKETED_WORD_PAT.matcher(s);
    while (m.find()) {
        ret.add(m.group());
    }
    return Collections.unmodifiableList(ret);
}

Answer 3

使用此：

/(?<![\[\w])\w+(?![\w\]])/

，即之前或之后没有方括号或字符的连续单词字符。

这需要检查左右两侧两个一个方括号和一个单词字符，否则输入[chicken]它只会返回< / p>

hicke

Answer 4

无需环顾四周：

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

public class MatchingTest
{
    private static String x = "pig [cow] chicken bull] [grain";

    public static void main(String[] args)
    {
        Pattern p = Pattern.compile("(\\[?)(\\w+)(\\]?)");
        Matcher m = p.matcher(x);
        while(m.find())
        {
            String firstBracket = m.group(1);
            String word = m.group(2);
            String lastBracket = m.group(3);
            if ("".equals(firstBracket) && "".equals(lastBracket))
            {
                System.out.println(word);
            }
        }
    }
}

输出：

pig
chicken

有点冗长，当然，但我发现它更易读，更容易理解。当然比试图处理所有可能的括号组合的巨大正则表达式更简单。

请注意，这不会过滤掉[fence tree grass]之类的输入;它表示tree是匹配的。如果没有解析器，你就不能跳过tree。希望这不是你需要处理的案例。

我将如何在Java Regex中执行此操作？

4 个答案: