Java 正则表达式的总结和一些小例子

字符串处理是许多程序中非常重要的一部分,它们可以用于文本显示,数据表示,查找键和很多目的.在Unix下,用户可以使用正则表达式的强健功能实现这些 目的,从Java1.4起,Java核心API就引入了java.util.regex程序包,它是一种有价值的基础工具,可以用于很多类型的文本处理, 如匹配,搜索,提取和分析结构化内容.

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。它包括两个类：Pattern和Matcher.
Pattern是一个正则表达式经编译后的表现模式。 在java中,通过适当命名的Pattern类可以容易确定String是否匹配某种模式.模式可以象匹配某个特定的String那样简单,也可以很复 杂,需要采用分组和字符类,如空白,数字,字母或控制符.因为Java字符串基于统一字符编码(Unicode),正则表达式也适用于国际化的应用程序.

Pattern类的方法简述

方法	说明
static Pettern compile(String regex,int flag)	编译模式, 参数 regex 表示输入的正则表达式 ,flag 表示模式类型 (Pattern. CASE_INSENSITIVE 表示不区分大小写 )
Matcher match(CharSequence input)	获取匹配器,input 时输入的待处理的字符串
static boolean matches(String regex, CharSequence input)	快速的匹配调用, 直接根据输入的模式 regex 匹配 input
String[] split(CharSequence input,int limit)	分隔字符串input,limit 参数可以限制分隔的次数

Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。首先一个Pattern实例订制了一个所用语法与 PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

Matcher类的方法简述

方法	说明
boolean matches()	对整个输入字符串进行模式匹配.
boolean lookingAt()	从输入字符串的开始处进行模式匹配
boolean find(int start)	从start 处开始匹配模式
int groupCount()	返回匹配后的分组数目
String replaceAll(String replacement)	用给定的replacement 全部替代匹配的部分
String repalceFirst(String replacement)	用给定的replacement 替代第一次匹配的部分
Matcher appendReplacement(StringBuffer sb,String replacement)	根据模式用replacement 替换相应内容 , 并将匹配的结果添加到 sb 当前位置之后
StringBuffer appendTail(StringBuffer sb)	将输入序列中匹配之后的末尾字串添加到sb 当前位置之后 .

正则表达式中常见通配符 :

对于单字符串比较而言,使用正则表达式没有什么优势.Regex的真正强大之处在于体现在包括字符类和量词( * , + , ? )的更复杂的模式上.
字符类包括:
\d  数字
\D  非数字
\w  单字字符( 0 - 9 ,A - Z,a - z)
\W 非单字字符
\s  空白(空格符,换行符,回车符,制表符)
\S 非空白
[]  由方括号内的一个字符列表创建的自定义字符类
.   匹配任何单个字符
下面的字符将用于控制将一个子模式应用到匹配次数的过程.
?   重复前面的子模式0次到一次
*   重复前面的子模式0次或多次
+  重复前面的子模式一次到多次

以下是实例部分:

实例一:

正则式是最简单的能准确匹配一个给定String的模式,模式与要匹配的文本是等价的.静态的Pattern.matches方法用于比较一个String是否匹配一个给定模式.例程如下:
String data = " java " ;
boolean  result = Pattern.matches( " java " ,data);

实例二:

 String[] dataArr  =  {  " moon " ,  " mon " ,  " moon " ,  " mono "  };

     for  (String str : dataArr) {
      String patternStr = " m(o+)n " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失败 " );
      }     
    }

模式是”m(o + )n”,它表示mn中间的o可以重复一次或多次,因此moon,mon,mooon能匹配成功,而mono在n后多了一个o,和模式匹配不上.

注:
+ 表示一次或多次; ? 表示0次或一次; * 表示0次或多次.

实例三:

 String[] dataArr  =  {  " ban " ,  " ben " ,  " bin " ,  " bon "  , " bun " , " byn " , " baen " };

     for  (String str : dataArr) {
      String patternStr = " b[aeiou]n " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失败 " );
      }     
    }

注:方括号中只允许的单个字符,模式“b[aeiou]n”指定,只有以b开头,n结尾,中间是a,e,i,o,u中任意一个的才能匹配上,所以数组的前五个可以匹配,后两个元素无法匹配.

方括号[]表示只有其中指定的字符才能匹配.

实例四:

String[] dataArr  =  {  " been " ,  " bean " ,  " boon " ,  " buin "  , " bynn " };

     for  (String str : dataArr) {
      String patternStr = " b(ee|ea|oo)n " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失败 " );
      }     
    }

如果需要匹配多个字符,那么[]就不能用上了,这里我们可以用()加上 | 来代替,()表示一组, | 表示或的关系,模式b(ee | ea | oo)n就能匹配been,bean,boon等.
因此前三个能匹配上,而后两个不能.

实例五:

String[] dataArr  =  {  " 1 " ,  " 10 " ,  " 101 " ,  " 1010 "  , " 100+ " };

     for  (String str : dataArr) {
      String patternStr = " \d+ " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失败 " );
      }     
    }

注:从前面可以知道,\d表示的是数字,而 + 表示一次或多次,所以模式\d + 就表示一位或多位数字.
因此前四个能匹配上,最后一个因为 + 号是非数字字符而匹配不上.

实例六:

String[] dataArr  =  {  " a100 " ,  " b20 " ,  " c30 " ,  " df10000 "  , " gh0t " };

     for  (String str : dataArr) {
      String patternStr = " \w+\d+ " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失败 " );
      }     
    }

模式\w + \d + 表示的是以多个单字字符开头,多个数字结尾的字符串,因此前四个能匹配上,最后一个因为数字后还含有单字字符而不能匹配.

实例七:

String str = " 薪水,职位 姓名;年龄 性别 " ;
    String[] dataArr  = str.split( " [,\s;] " );
     for  (String strTmp : dataArr) {
      System.out.println(strTmp); 
    }

String类的split函数支持正则表达式,上例中模式能匹配”,”,单个空格,”;”中的一个,split函数能把它们中任意一个当作分隔符,将一个字符串劈分成字符串数组.

实例八:

String str = " 2007年12月11日 " ;
Pattern p  =  Pattern.compile( " [年月日] " ); 
String[] dataArr  = p.split(str);
for  (String strTmp : dataArr) {
System.out.println(strTmp);
}

Pattern是一个正则表达式经编译后的表现模式 ,它的split方法能有效劈分字符串.
注意其和String.split()使用上的不同.

实例九:

String str = " 10元 1000人民币 10000元 100000RMB " ;
str = str.replaceAll( " (\d+)(元|人民币|RMB) " ,  " ￥ " );
System.out.println(str);

上例中,模式“(\d + )(元 | 人民币 | RMB)”按括号分成了两组,第一组\d + 匹配单个或多个数字,第二组匹配元,人民币,RMB中的任意一个,替换部分表示第一个组匹配的部分不变,其余组替换成￥.

替换后的str为￥ 10  ￥ 1000  ￥ 10000  ￥ 100000

实例十:

Pattern p  =  Pattern.compile( " m(o+)n " ,Pattern.CASE_INSENSITIVE);

//  用Pattern类的matcher()方法生成一个Matcher对象
Matcher m  =  p.matcher( " moon mooon Mon mooooon Mooon " );
StringBuffer sb  =   new  StringBuffer();

//  使用find()方法查找第一个匹配的对象
boolean  result  =  m.find();

//  使用循环找出模式匹配的内容替换之,再将内容加到sb里
while  (result) {
m.appendReplacement(sb,  " moon " );
result  =  m.find();
}
//  最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里；
m.appendTail(sb);

System.out.println( " 替换后内容是 "   +  sb.toString());

实例十一:

除了用 + 表示一次或多次, * 表示0次或多次, ? 表示0次或一次外,还可以用{}来指定精确指定出现的次数,X{ 2 , 5 }表示X最少出现2次,最多出现5次;X{ 2 ,}表示X最少出现2次,多则不限;X{ 5 }表示X只精确的出现5次.
例程:
String[] dataArr  =  {  " google " ,  " gooogle " ,  " gooooogle " ,  " goooooogle " , " ggle " };

for  (String str : dataArr) {
    String patternStr  =   " g(o{2,5})gle " ;

     boolean  result  =  Pattern.matches(patternStr, str);
     if  (result) {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  patternStr  +   " 成功 " );
    }  else  {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  patternStr  +   " 失败 " );
    }
}

实例十二:

表示从..到…,如[a - e]等同于[abcde]
 String[] dataArr  =  {  " Tan " ,  " Tbn " ,  " Tcn " ,  " Ton " , " Twn " };

     for  (String str : dataArr) {
      String regex  =   " T[a-c]n " ;

       boolean  result  =  Pattern.matches(regex, str);
       if  (result) {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  regex  +   " 成功 " );
      }  else  {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  regex  +   " 失败 " );
      }
    }

实例十三:不区分大小写匹配.

正则表达式默认都是区分大小写的,使用了Pattern.CASE_INSENSITIVE则不对大小写进行区分.

 String patternStr = " ab " ;
    Pattern pattern = Pattern.compile(patternStr, Pattern.CASE_INSENSITIVE);
    
    String[] dataArr  =  {  " ab " ,  " Ab " ,  " AB " };
    
     for  (String str : dataArr) {
      Matcher matcher = pattern.matcher(str);
      
       if (matcher.find()){
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  patternStr  +   " 成功 " );
      }
    }

实例十四:使用正则表达式劈分字符串.

 注意这里要把复杂的模式写在前面,否则简单模式会先匹配上.

String input = " 职务=GM 薪水=50000 , 姓名=职业经理人 ; 性别=男  年龄=45  " ;
    String patternStr = " (\s*,\s*)|(\s*;\s*)|(\s+) " ;
    Pattern pattern = Pattern.compile(patternStr);
    
    String[] dataArr = pattern.split(input);
    
     for  (String str : dataArr) {
      System.out.println(str);
    }

实例十五:解析正则表达式中的文字,对应第一个小括号括起来的group1.

String regex = " <(\w+)>(\w+)</> " ;
Pattern pattern = Pattern.compile(regex);
    
String input = " <name>Bill</name><salary>50000</salary><title>GM</title> " ;
    
Matcher matcher = pattern.matcher(input);
    
while (matcher.find()){
      System.out.println(matcher.group( 2 ));
}

实例十六:将单词数字混合的字符串的单词部分大写.

 

    String regex = " ([a-zA-Z]+[0-9]+) " ;   
    Pattern pattern = Pattern.compile(regex);
    
    String input = " age45 salary500000 50000 title " ;
    
    Matcher matcher = pattern.matcher(input);
    
    StringBuffer sb = new  StringBuffer();
    
     while (matcher.find()){
      String replacement = matcher.group( 1 ).toUpperCase();
      matcher.appendReplacement(sb, replacement);
    }
    matcher.appendTail(sb);
    
    System.out.println( " 替换完的字串为 " + sb.toString());