java＿正则表达式分解

 

　　有人在某BBS提问：“ 表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时，将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。
  怎么得出的这个结果???求详细过程啊,一步步的....((?=\1\1\1)(\1))+ 不理解括号里面的字符?”

　　曾经在正则投入不少时间，但"(\w)((?=\1\1\1)(\1))+"  仍花了大半天才弄明白。复杂的东西，都应逐步拆解。请看下面分解，不感兴趣部分自行跳过：
一、
1. (\w) -- \w,一个字符，括号表示一个子匹配,第一个括号是"\1"，第二个括号是"\2"，……。
2. (\w)(\1) -- 一个字符，后面紧跟一个相同的字符。
（之前复杂的正则，转为基本的(\w)(\1)。化繁为简，先弄清楚简单的，再向复杂推去。）

import java.util.regex.Matcher;import java.util.regex.Pattern;public class Test {        public static void main(String[] args) throws Exception        {                // Pattern pattern = Pattern.compile("(\\w)((?=\\1\\1\\1)(\\1))+");                Pattern pattern = Pattern.compile("(\\w)(\\1)");                Matcher matcher = pattern.matcher("aaa ffffff 999999999");                // Matcher matcher = pattern.matcher("aaa 999999");                while (matcher.find()) {                        System.out.print(matcher.group()+" | ");                }   }}

运行得：aa | ff | ff | ff | 99 | 99 | 99 | 99 | ，3个a,匹配了一次；6个f,匹配了三次；9个9,匹配了四次。
可见，(\w)(\1) -- 每次搜索两个字符，该字符与下一个相同即为true。

二、
1. (?=\\1) -- ?=，据“正则表达式系统教程"：

(?=pattern)  正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

2. (\\w)(?=\\1\\1\\1) -- 一个字符，后面紧跟三个相同的字符。但后三个字符不获取，也不消耗字符：如匹配“ffffff”，第一次查找，匹配到前四个ffff；第二次查找，从第二个“f”开始（不是从第五个开始，如无“?=”：(\\w)(\\1\\1\\1)，则是从第五个开始），匹配了第二个“f”至第五个“f”；第三次查找，匹配了第三个“f”至第六个“f”；第四次查找，只剩下三个“f”，匹配不到。

Pattern pattern = Pattern.compile("(\\w)(?=\\1\\1\\1)");

（其它代码见上，只改正则）

运行得：f | f | f | 9 | 9 | 9 | 9 | 9 | 9 | ，四个字符连续相同才符合条件，但每次查找只消耗一个字符，即 index只+1，不是+4。

 

三、

Pattern pattern = Pattern.compile("(\\w)(?=\\1\\1\\1)(\\1)");

运行得：ff | ff | 99 | 99 | 99 |
(\\w)(?=\\1\\1\\1)(\\1) --- 相当于执行一次(\\w)(?=\\1\\1\\1)匹配，接着执行一次(\\w)(\\1) ，移到下一个索引，再继续前面的操作，如此循环。
　　(\\w)(?=\\1\\1\\1)，参考“二、”，接着执行 (\\w)(\\1)，(\\w)已完成，到(\\1) 了，它从第二个“f”开始，查找前面的字符相同否，同，匹配。第二次查找，从第三个“f”开始，也是只消耗两个 “f" 字符。第三次查找，只剩下两个“f”，(\\w)(?=\\1\\1\\1)匹配不到。9个9的查找类同，三次查找后，余 9-2*3=3 个“9”，”，(\\w)(?=\\1\\1\\1)需4个“9”才合，查找结束。假如10个“9”的话，第四次能匹配成功，出现四个“99”。

四、

Pattern pattern = Pattern.compile("(\\w)(?=\\1\\1\\1)(\\1)+");

运行得：ffffff | 999999999 |
1. (\\1)+ --- +代表一个或多个，(\\1)+ 表示第一个的子匹配一个或多个。
2. (\\w)(?=\\1\\1\\1)(\\1)+ --- 相当于先 (\\w)(?=\\1\\1\\1)，再 (\\w)(\\1)+ ，接着下一索引继续。
　　(\\w)(?=\\1\\1\\1)，参考上面，接着执行 (\\1)+，从第二个“f”开始，它会将余下的“f” 全部匹配掉，“ffffff”的查找就结束了（接下来的是第二轮查找，对 9个“9”）。

五、

Pattern pattern = Pattern.compile("(\\w)((?=\\1\\1\\1)(\\1))+");

运行得：ffff | 9999999 |
1. ((?=\\1\\1\\1)(\\1))+  --- 是整个“(?=\\1\\1\\1)(\\1)”的一个或多个。先(?=\\1\\1\\1)，查找三个与第一个子匹配相合的；再(\\1) ，查找一个与第一个子匹配相合的；然后因有“+”，匹配多次。

2. (\\w)((?=\\1\\1\\1)(\\1))+  --- 以“ffffff” 6个“f” 为例：①执行(\\w)：找到一字符“f”，符合， ②执行(?=\\1\\1\\1)：从第二个“f”开始，查找三个“f”，符合， ③执行(\\1)：因前面不消耗字符，从第二个“f”开始，查找一个“f”，符合，④整个“(?=\\1\\1\\1)(\\1)”是 + 的，要匹配多次，相当于内循环，“(?=\\1\\1\\1)(\\1)”不断匹配下去，现从第三个“f”开始，查找三个“f”，符合，⑤现又到(\\1)，从第三个“f”开始，查找一个“f”，符合，⑥…………，最后到剩下2个“f”时，(?=\\1\\1\\1) 不合，结束此轮查找。这样，(\\w)只执行一次，匹配最前面的“f”，“(?=\\1\\1\\1)(\\1)”不断匹配，执行三次，匹配了第二至第四个“f”，总共匹配了前面的四个“f”。

3. 至此，对照LZ所提“将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个”，是吻合的。