java - 我将如何在 Java 正则表达式中执行此操作？

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
(?!\\])  //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(?!\\])?";

这基本上解释了两侧只有一个支架的两种情况。它通过|which 充当或来实现这一点，并通过?在前瞻/后视之后使用，其中?表示前一个表达式的 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]

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希望这不是您需要处理的情况。