正则表达式及其范例

一、前言部分

      控制台输入的字符串&＃xff0c;编译成java字符串之后才送进内存&＃xff0c;比如控制台打\&＃xff0c;送进内存的是\\

      java字符串中的特殊字符只有转义字符 \ 和表示边界的字符 " 

      转义字符的作用是&＃xff1a;&＃xff08;1&＃xff09;将边界符转义成普通字符

                                 &＃xff08;2&＃xff09;将自身转义成普通字符

                                 &＃xff08;3&＃xff09;将无法用26字母表示的输入转义出来&＃xff0c;如 \t 表示制表符 \r表示回车 \n表示换行等

     在java字符串&＃xff0c;字符 \ 只能组成\b  \t  \n  \f  \r  \"  \&＃39; \\ 这几种形式。

使用时&＃xff1a;

                Pattern pattern &＃61; Pattern.compile("\\d{6}");

      

      对于某些函数的正则表达式&＃xff08;字符串&＃xff09;参数&＃xff0c;比如split的参数&＃xff0c;写好正则表达式&＃xff0c;然后转义其中的java字符串特殊字符 \ 和 " 即可

二、使用范例简介&＃xff1a;

      &＃xff08;1&＃xff09;将正则表达式的字符串编译成pattern&＃xff0c;

        Pattern pattern &＃61; Pattern.compile("^Java.*");

      &＃xff08;2&＃xff09;利用pattern的matcher方法&＃xff0c;构造matcher对象&＃xff0c;参数是待匹配字符串&＃xff1a;Java不是人。

        Matcher matcher &＃61; pattern.matcher("Java不是人");

      &＃xff08;3&＃xff09;根据自己需求&＃xff0c;调用matcher的方法

      例如&＃xff1a;  

        boolean b&＃61; matcher.matches()   //当条件满足时&＃xff0c;将返回true&＃xff0c;否则返回falsematcher.replaceAll("Java") //返回的是替换后的字符串&＃xff0c;//调用find方法递归出匹配结果        while (matcher.find()) { System.out.printf( "I found the text \"%s\" starting at index %d and ending at index %d.%n", matcher.group(), matcher.start(), matcher.end() ); }

      

        另外&＃xff1a;Pattern对象还有个split方法&＃xff0c;来根据 正则表达式 分割串(三种:逗号 空格 竖线)      

        Pattern pattern1 &＃61; Pattern.compile("[, |]&＃43;");String[] strs &＃61; pattern1.split("Java Hello World  Java,Hello,,World|Sun");

        上述语句中字符 | 在方括号中&＃xff0c;表示普通字符&＃xff0c;不用转义&＃xff0c;当然转义也没错&＃xff1a;[, \\|]&＃43;&＃xff0c;但是用在括号外&＃xff0c;则一定转义

字符 - 在方括号中如果前面或后面没有数字&＃xff0c;不闭合&＃xff0c;则表示普通字符&＃xff1a;正则 [4-] 匹配 -    当然正则 [4\\-] 也匹配 -

 像^ * .等单独使用作为分割符&＃xff0c;虽然不会报错&＃xff08;可以通过java的字符串检查机制&＃xff09;&＃xff0c;但是结果会是意想不到。因此需要加上\\

三、简单规则

    ----------------------------------------------------------------------------

      正则表达式的特殊字符&＃xff08;元字符 meta characters&＃xff09;

&＃xff08;1&＃xff09; - 连字符&＃xff0c;在[]中用作范围时需要转义&＃xff0c;例如[0-9]

&＃xff08;2&＃xff09; \ 转义字符                     

             \\ 反斜杠   

             \t 制表符 (&＃39;/u0009&＃39;)

             \n 换行 (&＃39;/u000A&＃39;)

             \r 回车 (&＃39;/u000D&＃39;)

             \d 数字 等价于[0-9]     

             \D 非数字 等价于[^0-9]

             \s 空白符号 [/t/n/x0B/f/r]

             \S 非空白符号 [^/t/n/x0B/f/r]

             \w 单词字符 [a-zA-Z_0-9]

             \W 非单词字符 [^a-zA-Z_0-9]

             \b              单词边界  

                     er\b 匹配never,不能匹配version,因为er在一个词的中间 

                      \bdog\b   匹配dog 不匹配doggie

             \B              非单词边界  

                     \bdog\B   匹配doggie 不匹配dog

             \A 输入的开头

             \z 输入的结尾        

                    \G 上一个匹配的结尾

                     \Gdog  匹配dogdog两个&＃xff0c;匹配“dog dog”一个&＃xff0c;

                                  由于第二次出现的“dog”不是在前一个匹配结尾的开始      

&＃xff08;3&＃xff09; . 单个任意字符&＃xff08;除换行外&＃xff09;

&＃xff08;4&＃xff09; * 前面的字符出现0次以上

             J*     0个以上J

             .*     0个以上任意字符

             J.*D   J与D之间0个以上任意字符

            

&＃xff08;5&＃xff09; &＃43; 前面的字符出现1次以上

             J&＃43;     1个以上J

             .&＃43;     1个以上任意字符

             J.&＃43;D     J与D之间1个以上任意字符

&＃xff08;6&＃xff09; ^     以后面出现的字符开头   ^java 以Java为开头字符

&＃xff08;7&＃xff09; $ 以前面出现的字符结尾 java$ 以java为结尾字符

&＃xff08;8&＃xff09; []   里面出现的字符任意一个&＃xff08;待选字符连着写&＃xff0c;中间无空格&＃xff0c;如果是[, |] 则是三种分隔符&＃xff1a;空格 逗号 竖线&＃xff09;

              [aeio] aeio其中任意之一

                [0-9a-z] 0 to 9或a to z范围中一个字符

                 [0-9[a-z]]    0 to 9或a to z范围中一个字符(同上)&＃xff0c;并集

                [a-z&&[^bc]] a-z除去b和c中的任意一个&＃xff0c;&&是交集&＃xff0c;同&＃xff1a;[ad-z] 

                [^a-z] 不在a to z范围中的任意一个字符

&＃xff08;9&＃xff09; () 表示一个组&＃xff0c;其中的文字表示一个单位。前面的 &＃43; | $ ^ * 都可以用这个表示组来限定范围

                 (z|f)ood zood或food 

                 do(es)   do或does

                 &＃xff08;10&＃xff09; | 前后两者取一

                 J|A     J或A

                 Java|Hello   Java或Hello

                 z|food   z或food

                 (z|f)ood zood或food 

                

  &＃xff08;11&＃xff09;  {} 限制为连续出现指定次数字符

                 J{2}     JJ

                 J{3}     JJJ

                 J{3,}     JJJ,JJJJ,JJJJJ,???(3次以上J并存)

                 J{3,5}     JJJ或JJJJ或JJJJJ

(12) &＃xff1f; 匹配前面表达式0次或一次

                 非贪婪模式匹配

                 ja? j或者ja

                 do(es)?   do或does

四、 量词

----------------------------------------------------------------------------

    a? 可以匹配空字符串“” 可以匹配“a”串两次&＃xff08;一次是a 一次是结尾空串&＃xff09; 可以匹配“aaa”四次&＃xff08;三个a和一个结尾空串&＃xff09; 可以匹配“aaabab”七次&＃xff08;单独的a四次&＃xff0c;非a处&＃xff08;b&＃xff09;匹配两次&＃xff0c;结尾空串一次&＃xff09;          

       

      a* 可以匹配空字符串“” 可以匹配“a”串两次&＃xff08;一次是a 一次是结尾空串&＃xff09; 可以匹配“aaa”两次&＃xff08;一个aaa和一个结尾空串&＃xff09;可以匹配“aaabab”五次&＃xff08;aaa一次&＃xff0c;a一次&＃xff0c;非a处&＃xff08;b&＃xff09;匹配两次&＃xff0c;结尾空串一次&＃xff09;

      a&＃43; 只能匹配多个“a”的串  

      a{3} 匹配“aaa”一次 匹配“aaaaa”一次 匹配“aaaaaa”两次&＃xff08;aaa和aaa&＃xff09;

      a{3,} 匹配“aaaaaa”一次

      a{3,6} 匹配“aaaaaaaaa”两次&＃xff08;一次aaaaaa&＃xff0c;一次aaa&＃xff09;

      abc&＃43; 匹配“abc”&＃xff0c;“abcc”&＃xff0c;“abcccc...” 量词仅仅可能附在一个字符后面一次&＃xff08;此处依附的是c&＃xff09;

      [abc]&＃43; 匹配的是一个以上的abc中的字符组成的串

      (abc)&＃43;   匹配的是一个以上的abc串 如abc&＃xff0c; abcabcabc

五、贪婪式、勉强式、侵占式

----------------------------------------------------------------------------

<.*>     贪婪式 匹配了  

              &＃xff08;1&＃xff09;首先吞掉整个字符串&＃xff0c; <匹配 <&＃xff0c;然后.*匹配abbb>&＃xff0c;发现无法匹配 > 之后&＃xff0c;回退一个字符&＃xff08;>&＃xff09;

             &＃xff08;2&＃xff09;此时可以匹配

              从后向前回退

      <.*?> 勉强式 匹配了  

                  首先 <匹配 <&＃xff0c;吞掉a&＃xff0c;吞掉b&＃xff0c;吞掉b&＃xff0c;吞掉b&＃xff0c;发现 > 可以匹配

                从前向后吞并

      <.*&＃43;> 侵占式 无法匹配

                   首先 <匹配 <&＃xff0c;然后.*匹配abbb>&＃xff0c;发现无法匹配 > 之后&＃xff0c;不回退&＃xff0c;直接汇报无法匹配

                一次匹配结束

 

      对于待匹配串 xfooxxxxxxfoo

         .*foo 贪婪式 &＃xff08;1&＃xff09;吞掉整个串&＃xff0c;不匹配 &＃xff08;2&＃xff09;回退一个o&＃xff0c;不匹配

                             &＃xff08;3&＃xff09;回退一个o&＃xff0c;不匹配           &＃xff08;4&＃xff09;回退一个f&＃xff0c;匹配 xfooxxxxxxfoo

         .*?foo 勉强式 &＃xff08;1&＃xff09;匹配x&＃xff0c;匹配foo &＃xff08;2&＃xff09;继续&＃xff0c;匹配xxxxxx&＃xff0c;匹配foo

         .*&＃43;foo 侵占式 吞掉所有串&＃xff0c;无法匹配foo&＃xff0c;不回退&＃xff0c;匹配失败

六、捕捉组

----------------------------------------------------------------------------    

反向引用&＃xff1a;在正则表达式中&＃xff0c;反向引用使用反斜线&＃xff08;\&＃xff09;后跟一个表示需要再调用组号的数字来表示。

              例如&＃xff0c;表达式(\d\d)定义了匹配一行中的两个数字的捕获组&＃xff0c;通过反向引用\1&＃xff0c;表达式稍候会被再次调用。

(\d\d)\1 匹配1212&＃xff0c;而不能匹配1234 两组数字相同

七、边界匹配

 ----------------------------------------------------------------------------        

反向引用&＃xff1a;在正则表达式中&＃xff0c;反向引用使用反斜线&＃xff08;\&＃xff09;后跟一个表示需要再调用组号的数字来表示。

              例如&＃xff0c;表达式(\d\d)定义了匹配一行中的两个数字的捕获组&＃xff0c;通过反向引用\1&＃xff0c;表达式稍候会被再次调用。

(\d\d)\1 匹配1212&＃xff0c;而不能匹配1234 两组数字相同        

八、Pattern类的方法

    ----------------------------------------------------------------------------        

      &＃xff08;1&＃xff09;关于complain方法的第二个参数&＃xff08;整数&＃xff09;(可用位操作符|表示并列)

举例&＃xff1a;pattern &＃61; Pattern.compile("[az]$", Pattern.MULTILINE | Pattern.UNIX_LINES)        

           |-----------------------------------|-------------------|------------------------------------------------|

           |    使用标志构建模式                  |  内嵌标志表达式  |                 意义                                        |

           |-----------------------------------|-------------------|-------------------------------------------------|      

           | Pattern.CASE_INSENSITIVE    | 等价于(?i)         | 不区分大小写                                            |

          | Pattern.COMMENTS               | 等价于(?x)         | 忽略空白和以#开始的直到行尾的内嵌注释       |

           | Pattern.DOTALL                     | 等价于(?s)         | 表达式.匹配包括行结束符在内的任意字符         |

          |-----------------------------------|--------------------|------------------------------------------------|        

        &＃xff08;2&＃xff09;matches方法返回boolean方法

                Pattern.matches("\\d","1")

          &＃xff08;3&＃xff09;matcher方法返回Matcher类对象

                Pattern.matcher("待匹配字串")

        &＃xff08;4&＃xff09;split(方法

                Pattern pattern1 &＃61; Pattern.compile("[, |]");  

                String[] strs &＃61; pattern1.split("Java Hello World  Java,Hello,,World|Sun");

九、Matcher类的方法

----------------------------------------------------------------------------        

     

     &＃xff08;1&＃xff09;索引方法

                 start()                            匹配索引开始

                 start(int group)               组匹配索引开始

                end()                              匹配索引结束

                 end(int group)                组匹配索引结束    

     &＃xff08;2&＃xff09;研究方法

                matches()       boolean b&＃61; matcher.matches()     将整个匹配串与正则进行匹配的boolean值

                find方法&＃xff0c;查找下一个匹配的字符串序列,相当于rs.next

   

while (matcher.find()){System.out.printf(matcher.group(), matcher.start(), matcher.end() );}

            find(int index) 从索引处开始

            lookingAt()  与matches不同&＃xff0c;这个从头匹配&＃xff0c;有即可。

     &＃xff08;3&＃xff09;替换方法

        replaceFirst方法替换一个&＃xff0c; matcher.replaceFirst(String s);

        replaceAll方法替换所有匹配&＃xff08;参数是替换串&＃xff09; matcher.replaceAll(String s);

        str.replaceAll(regex, repl)方法与使用 Pattern.compile(regex).matcher(str).replaceAll(repl)    

十、参考

http://www.java3z.com/cwbwebhome/article/article8/Regex/Java.Regex.Tutorial.html