Pattern和Matcher详解（字符串匹配和字节码） （转http://blog.csdn.net/u010700335/article/details/44616451）

一：起因

（1）Java里面进行字符串操作，第一个想到的是String类 和 StringBuilder类 内含replace() 、replaceAll() 、split()、matches()等方法 —— 其实String类里面的           public String[] split(String regex, int limit) 和 matches()方法，调用是Pattern.compile().matches()方法 ----- 源码为：

        return Pattern.compile(regex).split(this, limit);

（2）String类里面的public String replaceAll(String regex, String replacement) 方法 也是一样的 ----- 源码为 ： 

      public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

（3）String类里面的public boolean matches(String regex)方法 也是一样的 ----- 源码为 ：

public boolean matches(String regex) {
        return Pattern.matches(regex, this);
    }

（4）相对于Java， C++语言就没有那么高大上了，连split() 和 trim()函数都没有，但是可以通过c++string类里面的其他函数实现，例如find_first_of / find_not_first_of() 等。

（5）java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现，(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳).

 

二：详解

（1）Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式,轮到Matcher类登场了,Pattern.matcher(CharSequence input)返回一个Matcher对象. Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例：

（2）find()对字符串进行匹配,匹配到的字符串可以在任何位置.  当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用如下三个方法得到更详细的信息Mathcer.start()/ Matcher.end()/ Matcher.group() 
start()返回匹配到的子字符串在字符串中的索引位置. 
end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置. 
group()返回匹配到的子字符串

 

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. Pattern p=Pattern.compile("\\d+");   
  2. Matcher m=p.matcher("aaa2223bb");   
  3. m.find();//匹配2223   
  4. m.start();//返回3   
  5. m.end();//返回7,返回的是2223后的索引号   
  6. m.group();//返回2223   
  7.   
  8. Mathcer m2=p.matcher("2223bb");   
  9. m2.lookingAt();   //匹配2223   
  10. m2.start();   //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0   
  11. m2.end();   //返回4   
  12. m2.group();   //返回2223   
  13.   
  14. Matcher m3=p.matcher("2223"); //如果Matcher m3=p.matcher("2223bb"); 那么下面的方法出错，因为不匹配返回false  
  15. m3.matches();   //匹配整个字符串   
  16. m3.start();   //返回0  
  17. m3.end();   //返回3,原因相信大家也清楚了,因为matches()需要匹配所有字符串   
  18. m3.group();   //返回2223  
  19.   
  20. 说说正则表达式的分组在java中是怎么使用的.   
  21. start(),end(),group()均有一个重载方法它们是start(int i),end(int i),group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组.  

三：案例回放

（1）简单练习

 

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.         String phones1 = "MKY 的手机号码：0939-100391"   
  3.                 +"XL 的手机号码：0939-666888aaaa"  
  4.                 +"LJ 的手机号码：0952-600391"   
  5.                 +"XQZ 的手机号码：0939-550391";;  
  6.         String regex = ".*0939-\\d{6}";  
  7.         Pattern pattern = Pattern.compile(regex);  
  8.         Matcher matcher = pattern.matcher(phones1);  
  9.   
  10.         while(matcher.find()) {  
  11.             System.out.println(matcher.group()+"&&&&&");  
  12.             System.out.println("start: " + matcher.start());  
  13.             System.out.println("end: " + matcher.end());  
  14.         }// 仅仅返回一个结果的,返回最长的结果，而不是一截一截的  
  15.           
  16.         String phones2 = "LJ 的手机号码：0952-600391\r\n"   
  17.                         +"XQZ 的手机号码：0939-550391";  
  18.         //重用pattern  
  19.         matcher = pattern.matcher(phones2);  
  20.   
  21.         while(matcher.find()) {  
  22.             System.out.println(matcher.group());  
  23.         }  
  24.         // 另外一个pattern  
  25.         String text = "abcdebcadxbc";  
  26.         regex = ".bc";  
  27.         Pattern pattern2 = Pattern.compile(regex);  
  28.         matcher = pattern2.matcher(text);  
  29.   
  30.         while(matcher.find()) {  
  31.             System.out.println(matcher.group()+"****");  
  32.             System.out.println("start: " + matcher.start());  
  33.             System.out.println("end: " + matcher.end());  
  34.         }// 返回结果的是多个的  
  35.         System.out.println("*************");  
  36.         // 下面是两个非常重要的  
  37.         pattern = Pattern.compile("<.+?>", Pattern.DOTALL);   
  38.         matcher = pattern.matcher("<a href=\"index.html\">主页</a>");   
  39.         String string = matcher.replaceAll("");   
  40.         System.out.println(string);   
  41.           
  42.         pattern = Pattern.compile("href=\"(.+?)\"");   
  43.         matcher = pattern.matcher("<a href=\"index.html\">主页</a>");   
  44.         if(matcher.find())   
  45.           System.out.println(matcher.group(1));   
  46.     }  


（2）Java 正则表达式（此部分为转载）


 现在通过一些实验来说明正则表达式的匹配规则,这儿是Greedy方式
  .              任何字符
 a?             a一次或一次也没有
 a*             a零次或多次
 a+            a一次或多次
 a{n}?      a恰好 n 次
 a{n,}?       a至少n次 
 a{n,m}?   a至少n次，但是不超过m次


//初步认识. * + ?
        p("a".matches("."));//true
        p("aa".matches("aa"));//true
        p("aaaa".matches("a*"));//true
        p("aaaa".matches("a+"));//true
        p("".matches("a*"));//true
        p("aaaa".matches("a?"));//false
        p("".matches("a?"));//true
        p("a".matches("a?"));//true
        p("1232435463685899".matches("\\d{3,100}"));//true
        p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));//false
        p("192".matches("[0-2][0-9][0-9]"));//true [abc]                        a、b 或 c（简单类）
[^abc]                      任何字符，除了 a、b 或 c（否定）
[a-zA-Z]                   a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]                a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]             d、e 或 f（交集）
[a-z&&[^bc]]             a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]            a 到 z，而非 m 到 p：[a-lq-z]（减去）
//范围
        p("a".matches("[abc]"));//true
        p("a".matches("[^abc]"));//false
        p("A".matches("[a-zA-Z]"));//true
        p("A".matches("[a-z]|[A-Z]"));//true
        p("A".matches("[a-z[A-Z]]"));//true
        p("R".matches("[A-Z&&[RFG]]"));//true
\d                          数字：[0-9]
\D                         非数字： [^0-9]
\s                          空白字符：[ \t\n\x0B\f\r]
\S                         非空白字符：[^\s]
\w                         单词字符：[a-zA-Z_0-9]
\W                        非单词字符：[^\w]
         //认识\s \w \d \
        p("\n\r\t".matches("\\s(4)"));//false
        p(" ".matches("\\S"));//false
        p("a_8 ".matches("\\w(3)"));//false
        p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));//true
        p("\\".matches("\\\\"));//true

 边界匹配器
      ^                                          行的开头
      $                                          行的结尾
      \b                                        单词边界
      \B                                        非单词边界
      \A                                        输入的开头
      \G                                       上一个匹配的结尾
      \Z                                       输入的结尾，仅用于最后的结束符（如果有的话）
      \z                                       输入的结尾
//边界匹配
        p("hello sir".matches("^h.*"));//true
        p("hello sir".matches(".*ir$"));//true
        p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));//true
        p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));//false
        //空白行:一个或多个(空白并且非换行符)开头，并以换行符结尾
        p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));//true

重点说明
表示<>之间有任意一个（含）字符以上，括号表示捕获组，匹配后可以单独提取出括号内的内容，?代表最短匹配，比如<asdf>>>这样的输入，有？会匹配成<asdf>，没有？会匹配整个<asdf>>>。

str.ReplactAll("<(.)+?>","")就是把所有<>间有一个字符以上的文字都替换为空。比如
asdf<1234>jkl<>会变成asdfjkl<>
另外要是str_line.replaceAll("&(.)+?;"," ") 是将&开头的包含任意字符的右面的最短匹配并以;结束的都替换成为空

四：java 字节码

（1）

 ldc将int, float或String型常量值从常量池中推送至栈顶
 iload 将指定的int型本地变量推送至栈顶
 lload 将指定的long型本地变量推送至栈顶
 （2）
 fstore 将栈顶float型数值存入指定本地变量
 dstore 将栈顶double型数值存入指定本地变量
 astore 将栈顶引用型数值存入指定本地变量
 istore_1 将栈顶int型数值存入第二个本地变量
 astore_1 将栈顶引用型数值存入第二个本地变量
 astore_2 将栈顶引用型数值存入第三个本地变量

 pop 将栈顶数值弹出 (数值不能是long或double类型的)
 dup 复制栈顶数值并将复制值压入栈顶
 
 iadd 将栈顶两int型数值相加并将结果压入栈顶
 ladd 将栈顶两long型数值相加并将结果压入栈顶
 isub 将栈顶两int型数值相减并将结果压入栈顶
 imul 将栈顶两int型数值相乘并将结果压入栈顶
（3）
 ireturn 从当前方法返回int
 areturn 从当前方法返回对象引用
 return 从当前方法返回void
 
 getstatic 获取指定类的静态域，并将其值压入栈顶
 putstatic 为指定的类的静态域赋值
 getfield 获取指定类的实例域，并将其值压入栈顶
 putfield 为指定的类的实例域赋值
 
 invokevirtual 调用实例方法
 invokespecial 调用超类构造方法，实例初始化方法，私有方法
 invokestatic 调用静态方法
 invokeinterface 调用接口方法
 （4）
 new 创建一个对象，并将其引用值压入栈顶
 newarray 创建一个指定原始类型（如int, float, char…）的数组，并将其引用值压入栈顶
 
 if_icmpgt 比较栈顶两int型数值大小，当结果大于0时跳转
 if_icmple 比较栈顶两int型数值大小，当结果小于等于0时跳转

五：String类的源码分析

 

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. <strong> (</strong>1)  subString()  ---  public String substring(int beginIndex, int endIndex)  
  2.    
  3.      /** 
  4.      * Returns a new string that is a substring of this string. The 
  5.      * substring begins at the specified <code>beginIndex</code> and 
  6.      * extends to the character at index <code>endIndex - 1</code>. 
  7.      * Thus the length of the substring is <code>endIndex-beginIndex</code>. 
  8.      * <p> 
  9.      * Examples: 
  10.      * <blockquote><pre> 
  11.      * "hamburger".substring(4, 8) returns "urge" 
  12.      * "smiles".substring(1, 5) returns "mile" 
  13.      * </pre></blockquote> 
  14.      * 
  15.      * @param      beginIndex   the beginning index, inclusive. 
  16.      * @param      endIndex     the ending index, exclusive. 
  17.      * @return     the specified substring. 
  18.      * @exception  IndexOutOfBoundsException  if the 
  19.      *             <code>beginIndex</code> is negative, or 
  20.      *             <code>endIndex</code> is larger than the length of 
  21.      *             this <code>String</code> object, or 
  22.      *             <code>beginIndex</code> is larger than 
  23.      *             <code>endIndex</code>. 
  24.      */  
  25.     public String substring(int beginIndex, int endIndex) {  
  26.         if (beginIndex < 0) {  
  27.             throw new StringIndexOutOfBoundsException(beginIndex);  
  28.         }  
  29.         if (endIndex > count) {  
  30.             throw new StringIndexOutOfBoundsException(endIndex);  
  31.         }  
  32.         if (beginIndex > endIndex) {  
  33.             throw new StringIndexOutOfBoundsException(endIndex - beginIndex);  
  34.         }  
  35.         return ((beginIndex == 0) && (endIndex == count)) ? this :  
  36.             new String(offset + beginIndex, endIndex - beginIndex, value);  
  37.     }  
  38.     
  39.  (2) -- indexOf(ch)  indexOf(String str) 匹配整个str才返回首位置  
  40. /** 
  41.      * Code shared by String and StringBuffer to do searches. The 
  42.      * source is the character array being searched, and the target 
  43.      * is the string being searched for. 
  44.      * 
  45.      * @param   source       the characters being searched. 
  46.      * @param   sourceOffset offset of the source string. 
  47.      * @param   sourceCount  count of the source string. 
  48.      * @param   target       the characters being searched for. 
  49.      * @param   targetOffset offset of the target string. 
  50.      * @param   targetCount  count of the target string. 
  51.      * @param   fromIndex    the index to begin searching from. 
  52.      */  
  53.     static int indexOf(char[] source, int sourceOffset, int sourceCount,  
  54.                        char[] target, int targetOffset, int targetCount,  
  55.                        int fromIndex) {  
  56.         if (fromIndex >= sourceCount) {  
  57.             return (targetCount == 0 ? sourceCount : -1);  
  58.         }  
  59.         if (fromIndex < 0) {  
  60.             fromIndex = 0;  
  61.         }  
  62.         if (targetCount == 0) {  
  63.             return fromIndex;  
  64.         }  
  65.   
  66.         char first  = target[targetOffset];  
  67.         int max = sourceOffset + (sourceCount - targetCount);  
  68.   
  69.         for (int i = sourceOffset + fromIndex; i <= max; i++) {  
  70.             /* Look for first character. */  
  71.             if (source[i] != first) {  
  72.                 while (++i <= max && source[i] != first);  
  73.             }  
  74.   
  75.             /* Found first character, now look at the rest of v2 */  
  76.             if (i <= max) {  
  77.                 int j = i + 1;  
  78.                 int end = j + targetCount - 1;  
  79.                 for (int k = targetOffset + 1; j < end && source[j] ==  
  80.                          target[k]; j++, k++);  
  81.   
  82.                 if (j == end) {  
  83.                     /* Found whole string. */  
  84.                     return i - sourceOffset;  
  85.                 }  
  86.             }  
  87.         }  
  88.         return -1;  
  89.     }   

(3)总之，C++的string类里面的find_first_of() 和 Java里的indexOf()不一样的，substring()  貌似没有

posted @ 2016-12-21 11:05  星火spark  阅读(4683)  评论(0)  编辑  收藏  举报