Java正则表达式入门

正则表达式以一种强大而灵活的文本处理工具，使用正则表达式我们能够以编程的方式构造复杂的文本模式，并对输入的字符串进行搜索。
初学正则表达式时，语法是一个难点，在Java的正则表达式中要注意：

  \\     表示的是“我要插入一个正则表达式反斜杠，所以其后面的字符具有特殊意义”，例如：\\d   表示整数

   |     表示或

  \t     表示制表符 TAB

  \n    表示换行符

  \r     表示回车

  \f     表示换页

  \e    表示转义（Escape）

常用字符类：

  .                 任意字符

  [abc]          表示包含 a、b 和 c 的任意字符（和 a|b|c 作用相同）

  [^abc]         表示除了 a、b和 c 之外的任何字符（否定）

  [a-zA-Z]      表示从 a 到 z 或 A-Z 的任何字符（范围）

  [abc[hij]]      表示a、b、c、h、i 和 j 字符（表示合并）

  [a-z&&[hij]]  表示任意h、i 或 j

  \s                表示空白符

  \S                表示非空白符 ( [ ^\s ] )

  \d                 数字 [0-9]

  \D                非数字[^0-9]

  \w                词字符[a-zA-Z0-9]

  \W               非词字符[^\w]

逻辑操作符：

  XY               Y跟在X后面

  X|Y              X或Y

  (X)              捕获组（capturing group）可以在表达式中用 \i 引用第i个捕获组

边界匹配符：

^                    一行的起始

$                   一行的结束

\b                  词的边界

\B                  非词的边界

\G                  前一个匹配的结束

package com.xuzhenhao.demo;  
  
public class TestRegular {  
      
    public static void main(String[] args) {  
          
        for (String string : new String[]{"TestRegular","[tT]estRegular","[tT][abcde][a-z].*",".*","\\w+"}) {  
            System.out.println("TestRegular".matches(string));  
        }  
    }  
  
} 

我们发现打印出来的结果都是true,对应上面的表达式，不难理解！

true  
true  
true  
true  
true

量词

量词描述了一个模式吸收输入文本 的方式，其有三种类型：

贪婪型： 量词总是贪婪的，除非有其他的选项被设置，贪婪表达式会为所有可能的模式发现尽可能多的匹配。导致此问题的一个典型的理由就是嘉定我们的模式仅能匹配第一个可能的字符组，如果他是贪婪的，那么他就会继续往下匹配。

勉强型：用问号来指定，这个量词匹配满足模式所需的最少字符数，因此也称为懒惰的、最少匹配的、非贪婪的。

占有型：目前这种类型的量词只在java中可用，并且更高级。

                                                                         贪婪型        勉强型         占有型            如何匹配

                                                                            X?             X??               X?+              一个或多个X

                                                                            X*             X*?                X*+              零个或者多个X

                                                                            X+            X+?               X++             一个或者多个X

                                                                           X{n}          X{n}?             X{n}+           恰好n次X

                                                                           X{n,}         X{n,}?            X{n,}+          至少n次X

                                                                           X{n,m}      X{n,m}?        X{n,m}+       X至少n次，且不超过m次

注意： X最好用小括号括起来。

Pattern（模式）和Matcher（匹配）

Pattern对象表示编译后的正则表达式，通过Pattern的compile（编译）方法来编译正则表达式，并返回一个Pattern对象。
再通过Pattern对象的matcher()方法获得一个Matcher对象。Matcher对象下有多个方法，如下：

boolean matches() 

用途：用来判断整个输入的字符串是否匹配正则表达式模式。

boolean lookingAt()
用途：用来判断输入的字符串的起始部分是否可以匹配正则表达式模式。

boolean find()

用途：试图找到匹配模式的输入序列中的下一个序列。这个方法开始在这个匹配的区域，开始或，如果前一个调用的方法是成功的，

匹配之后没有复位，在不匹配的第一个字符之前的比赛。如果匹配成功，则可以通过开始、结束和组方法获得更多信息。

boolean find(int start)

用途：这个重置匹配然后试图找到匹配模式的输入序列中的下一个序列，并从指定索引处开始。

如果匹配成功则更多的信息可以通过开始，结束了，和组的方法，并随后将（）方法调用将在不匹配的这种匹配的第一个字符开始。

Pattern（模式）和Matcher（匹配）的实践

public class TestRegular {  
          
     public static void main(String[] args) {  
              
        String s = "Java now has regular expressions";  
        String [] regex = new String []{"^java","\\Breg.*","n.w\\s+h(a|i)s","n?","s*","s+","s{4}","s{1}.","s{0,3}"};  
        for (String string : regex) {  
       Pattern pattern = Pattern.compile(string);  
       Matcher matcher = pattern.matcher(s);  
       System.out.println(matcher.find());  
     }         
   }  
}  

匹配结果如下：

待续... ...