Java 正则表达式Pattern/Matcher

1. 正则表达式的书写

   Pattern是一个正则表达式经编译后的表现模式。

   Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。

   工作原理：一个正则表达式，也就是一串有特定意义的字符，必须首先要编译成为一个Pattern类的实例，这个Pattern对象将会使用matcher()方法来生成一个Matcher实例，接着便可以使用该 Matcher实例以编译的正则表达式为基础对目标字符串进行匹配工作，多个Matcher是可以共用一个Pattern对象的。 

        pattern类：

        1.将给定的正则表达式编译并赋予给Pattern类：

        static Pattern compile(String regex)；

     2.将目标字符串按照Pattern里所包含的正则表达式为模进行分割：

        String[] split(CharSequence input) ————> 限制分割的次数： String[] split(CharSequence input, int limit)

        实例：

                    import java.util.regex.Pattern;

                    public class TestRegex {  

                     public static void main(String[] args) throws Exception {   

                      //生成一个Pattern,同时编译一个正则表达式   

                     Pattern p = Pattern.compile("[/]+");   

                     //用Pattern的split()方法把字符串按"/"分割   

                     String[] result = p.split(   

                     "尊敬的${name}会员，"   

                     +"/欢迎注册ASADD，验证码是${1233}"   

                     +"/.祝您在${form}愉快。");   //当p.split("*****",2)输出结果只有两段，最后一段不会截取

                     for (int i=0; i<result.length; i++)   

                     System.err.println(result[i]);

                    }

        输出结果：

                            尊敬的${name}会员，

                            欢迎注册ASADD，验证码是${1233}

                            .祝您在${form}愉快。

        Matcher类：

       1. 一个Matcher对象是由一个Pattern对象调用其matcher()方法而生成的，一旦该Matcher对象生成,它就可以进行三种不同的匹配查找操作： 
        matches()方法尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。 
        lookingAt ()方法将检测目标字符串是否以匹配的子串起始。 
        find()方法尝试在目标字符串里查找下一个匹配子串。 
        以上三个方法都将返回一个布尔值来表明成功与否。 

           实例：

                

                import java.util.HashSet;

                import java.util.Set;

                import java.util.regex.Matcher;

                import java.util.regex.Pattern;

                public class TestRegex {  

                     public static void main(String[] args) throws Exception {   

                 Pattern p=Pattern.compile("(\\$\\{[~!@#%^&*+=_.<>/￥%*——a-zA-Z0-9]{0,}\\})");

                 Matcher matcher=p.matcher("尊敬的${name}会员，欢迎注册ASADD，验证码是${1233}.祝您在${form}愉快");

                 //检查字符串是不是以${}为起始,返回true或者false

                 System.err.println("检查字符串是不是以${}为起始:"+matcher.lookingAt());

                 //尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。   

                 System.err.println("对整个目标字符展开匹配检测:"+matcher.matches() );

                 //将所有的匹配到的${**}替换

                 //String content = matcher.replaceAll("2");

                 //System.err.println(content);

                 //将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。

                 String content=matcher.replaceFirst("小明");

                 System.err.println(content);

                 //返回当前查找所获子串的开始字符在原目标字符串中的位置。 

                 int start=matcher.start();

                 System.err.println("返回当前查找所获子串的开始字符在原目标字符串中的位置:"+start);

                 Set<String> set = new HashSet<String>();

                 while(matcher.find()){

                         //返回当前查找而获得的与组匹配的所有子串内容

                 System.err.println(“返回当前查找而获得的与组匹配的所有子串内容：”+matcher.group());

                 //将${name}——>变为name

                 set.add(matcher.group().replaceAll("[$\\{\\}]", ""));

                 }

                 for(String s:set){

                 System.err.println(s);

                 }

                 }   

                 } 

                   输出结果：       

                                         检查字符串是不是以${}为起始:false

                                                    对整个目标字符展开匹配检测:false

                                                    尊敬的小明会员，欢迎注册ASADD，验证码是${1233}.祝您在${form}愉快

                                                    返回当前查找所获子串的开始字符在原目标字符串中的位置: 3

                                                    返回当前查找而获得的与组匹配的所有子串内容: ${1233}

                                                    返回当前查找而获得的与组匹配的所有子串内容: ${form}

                                                    1233

                                                    form

            

            2.Matcher类同时提供了四个将匹配子串替换成指定字符串的方法： 

1. 1. 1. 1. replaceAll()   

         2. replaceFirst()   

         3. appendReplacement()   

         4. appendTail()   

            前面的代码已经说明了前两种下面介绍后面的：
              appendReplacement(StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个

          StringBuffer对象里，而appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

            

                                    //该例将把句子里的"Kelvin"改为"Kevin"   

                                    import java.util.regex.*;   

                                    public class MatcherTest{   

                                    public static void main(String[] args)   

                                    throws Exception {   

                                    //生成Pattern对象并且编译一个简单的正则表达式"Kelvin"   

                                    Pattern p = Pattern.compile("Kevin");   

                                    //用Pattern类的matcher()方法生成一个Matcher对象   

                                    Matcher m = p.matcher("Kelvin Li and Kelvin Chan are both working in Kelvin Chen's KelvinSoftShop company");   

                                    StringBuffer sb = new StringBuffer();   

                                    int i=0;   

                                    //使用find()方法查找第一个匹配的对象   

                                    boolean result = m.find();   

                                    //使用循环将句子里所有的kelvin找出并替换再将内容加到sb里   

                                    while(result) {   

                                    i++;   

                                    m.appendReplacement(sb, "Kevin");   

                                    System.out.println("第"+i+"次匹配后sb的内容是："+sb);   

                                    //继续查找下一个匹配对象   

                                    result = m.find();   

                                    }   

                                    //最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里；   

                                    m.appendTail(sb);   

                                    System.out.println("调用m.appendTail(sb)后sb的最终内容是:"+ sb.toString());   

                                    }   

                                    }   

                                      

                                    最终输出结果为：   

                                    第1次匹配后sb的内容是：Kevin   

                                    第2次匹配后sb的内容是：Kevin Li and Kevin   

                                    第3次匹配后sb的内容是：Kevin Li and Kevin Chan are both working in Kevin   

                                    第4次匹配后sb的内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's Kevin   

                                    调用m.appendTail(sb)后sb的最终内容是：                                          Kevin Li and Kevin Chan are both working in Kevin Chen's KevinSoftShop company.   

  

常用：

正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。

匹配中文字符的正则表达式： [\u4e00-\u9fa5]

匹配HTML标记的正则表达式（一）：<(\S*?)[^>]*>.*?</\1>|<.*? />

匹配HTML标记的正则表达式（二）：<[\\w|\\W]+?>

匹配Email地址的正则表达式：\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配网址URL的正则表达式（一）：http(s)?://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

匹配网址URL的正则表达式（二）：[a-zA-z]+://[^\s]*

匹配ip地址的正则表达式：\d+\.\d+\.\d+\.\d+

匹配日期的正则表达式：^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$

匹配日期的正则表达式：^\d{17}[\d|X]|\d{15}$