Regex 如何使用正则表达式计算奇数和偶数字符数？

我试着把所有有偶数个B和奇数个C的字符串都拉出来。我的正则表达式可以匹配奇数A和偶数B，但我无法让这两个正则表达式一起工作。字符串由空格（制表符、换行符、空格）分隔

e、 g

我有奇数的A

\b[^A]*A([^A]*A[^A]*A)*[^A]*\b

即使是B

\b[^B]*(B[^B]*B[^B]*)*[^B]*\b

我知道我需要使用+ve lookahead并已尝试：

\b(?=[^A]*A([^A]*A[^A]*A)*[^A]*\b)[^B]*(B[^B]*B[^B]*)*[^B]*\b

---

但是它不起作用-有人知道为什么吗？

问题是您的正则表达式（regexen？）可以匹配零个字符-

\b\b

将在单个单词边界上匹配，

\b{someregexthatchatmatchzerocharacters}\b
问题是您的正则表达式（regexen？）也会匹配可以匹配零字符-
\b\b
将在单个单词边界上匹配，因此
\b{someregexthatcanmatchzerocharacters}\b
正如前面提到的：您的模式匹配空字符串，导致
m.find（）
永远不会在目标字符串中前进。因此，您需要让偶数
B
实际匹配包含2,4,6。。。
B
的数量。如果需要，您可以在偶数个
B
和以下两种类型之间进行切换：
[^B\\s]+
（与包含0
B
的字符串相匹配）。只要你真的匹配了一个或多个角色，你就应该没事了

另外，您不希望向前看，让被否定的类匹配空格：这样您会得到太多的匹配

试着这样做：

String text = "XABBAC     ABCDEBCC ABSDERERES ABBAAJSER     HGABAA";

String oddAs = "\\b[^A\\s]*A([^A\\s]*A[^A\\s]*A)*[^A\\s]*\\b";
String evenBs = "\\b([^B\\s]*(B[^B\\s]*B[^B\\s]*)+|[^B\\s]+)\\b";

Pattern p = Pattern.compile(String.format("(?=%s)(?=%s)\\S+", oddAs, evenBs));
Matcher m = p.matcher(text);

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

产生：

ABCDEBCC
ABBAAJSER

正如前面提到的：您的模式匹配空字符串，导致
m.find（）
永远不会在目标字符串中前进。因此，您需要让偶数
B
实际匹配包含2,4,6。。。
B
的数量。如果需要，您可以在偶数个
B
和以下两种类型之间进行切换：
[^B\\s]+
（与包含0
B
的字符串相匹配）。只要你真的匹配了一个或多个角色，你就应该没事了

另外，您不希望向前看，让被否定的类匹配空格：这样您会得到太多的匹配

试着这样做：

String text = "XABBAC     ABCDEBCC ABSDERERES ABBAAJSER     HGABAA";

String oddAs = "\\b[^A\\s]*A([^A\\s]*A[^A\\s]*A)*[^A\\s]*\\b";
String evenBs = "\\b([^B\\s]*(B[^B\\s]*B[^B\\s]*)+|[^B\\s]+)\\b";

Pattern p = Pattern.compile(String.format("(?=%s)(?=%s)\\S+", oddAs, evenBs));
Matcher m = p.matcher(text);

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

产生：

ABCDEBCC
ABBAAJSER

regex被高估了

    String str = "XABBAC     ABCDEBCC ABSDERERES ABBAAJSER     HGABAA";
    String[] s = str.split("\\s+");
    for (int j=0 ;j< s.length;j++) {
        int countC=0  ;
        int countB=0;
        for(int i=0;i<s[j].length();i++){
            char c = s[j].charAt(i) ;
            if (c == 'C') countC++;
            if (c == 'B') countB++;
        }
        if ( (countC % 2) != 0 )
            System.out.println( s[j] + " has odd C");
        if ( (countB % 2) == 0 )
            System.out.println( s[j] + " has even B");
    }

String str=“XABBAC ABCDEBCC absderes ABBAAJSER HGABAA”；
字符串[]s=str.split（\\s+）；
对于（int j=0；j
    String str = "XABBAC     ABCDEBCC ABSDERERES ABBAAJSER     HGABAA";
    String[] s = str.split("\\s+");
    for (int j=0 ;j< s.length;j++) {
        int countC=0  ;
        int countB=0;
        for(int i=0;i<s[j].length();i++){
            char c = s[j].charAt(i) ;
            if (c == 'C') countC++;
            if (c == 'B') countB++;
        }
        if ( (countC % 2) != 0 )
            System.out.println( s[j] + " has odd C");
        if ( (countB % 2) == 0 )
            System.out.println( s[j] + " has even B");
    }

String str=“XABBAC ABCDEBCC absderes ABBAAJSER HGABAA”；
字符串[]s=str.split（\\s+）；
对于（int j=0；j对于（int i=0；i和commons.lang.StringUtils，它更简洁：

String data = "XABBAC     ABCDEBCC ABSDERERES ABBAAJSER    HGABAA";
String[] items = data.split("\\s+");

for(String item: items ) {
    if (countMatches(item, "B") % 2 == 0
     && countMatches(item, "C") % 2 != 0) {
        System.out.println( item );
    }
}

commons.lang.StringUtils更简洁：

String data = "XABBAC     ABCDEBCC ABSDERERES ABBAAJSER    HGABAA";
String[] items = data.split("\\s+");

for(String item: items ) {
    if (countMatches(item, "B") % 2 == 0
     && countMatches(item, "C") % 2 != 0) {
        System.out.println( item );
    }
}

似乎有效。你能给出一个不适用于你的示例，并给出你的Java代码吗？@marcog LOL。在ruby中，这将是一个简单的单行程序。
data.split。选择{x | x.count（“B”）。偶数和&x.count（“C”）。奇数}
结果：
[“XABBAC”，“ABCDEBCC”]
“问题”？说真的？这就是你给它贴上的标签？与所有其他不涉及问题的问题相反？…重新标记…似乎有效。你能举一个例子说明它对你不起作用，并给出你的Java代码吗？@marcog LOL。在ruby中，这将是一个简单的一行程序。
data.split。选择{x | x.count（“B”）。甚至？&&x.count(“C”）.odd？}
结果：
[“XABBAC”，“ABCDEBCC”]
问题"？说真的？这就是你给它加的标签？与所有其他不涉及问题的问题相反？…重新标记…@dr85：是的，它会。但是，它不会消耗任何字符-
\b\b
将匹配单个单词边界；第一个
\b
匹配一个边界，然后引擎尝试匹配第二个
\b
，它仍然在单词边界上，所以它匹配。@dr85：是的，它匹配。但是，它不使用任何字符-
\b\b
将匹配单个单词边界；第一个
\b
匹配一个边界，然后引擎尝试匹配第二个
\b
，它仍然在单词边界上，所以它匹配。您好，您能解释一下吗告诉我你在patter.compile中传递了什么？谢谢你的回复。尤其是%s？@dr85，
String.format
返回一个字符串（2
%s
被
oddAs
和
evenBs
替换）。这与执行以下操作相同：
（？=“+oddAs+”（“+evenBs+”）\\s+”）
并将其输入静态
模式。compile（…）
方法。@dr85，与其想知道我发布的代码片段做什么和不做什么，为什么不试试呢？它与
ababababababba
不匹配（我刚刚测试过）。我可以问一下为什么要用两个lookaheads吗？一个lookaheads不可能吗？嗨，你能解释一下你在patter.compile中传递了什么吗？谢谢你的回答。特别是什么是%s？@dr85，
String.format
返回一个字符串（2
%s
被
oddAs
和
evenBs
）。这与执行以下操作相同：
“（？=”+oddAs+”（=“+evenBs+”）\\S+”
，并将其输入静态
模式。编译（…）
方法。@dr85，与其想知道我发布的代码片段做什么和不做什么，为什么不尝试它？它与
ababababababababa
不匹配（我刚刚测试过）.我能问一下你为什么用两个lookahead吗？一个就不可能吗？