爪哇国新游记之三十----十九个正则表达式示例

1.重复次数匹配
代码：

        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+"失败");
          }     
        }

输出：

字符串moon匹配模式m(o+)n成功
字符串mon匹配模式m(o+)n成功
字符串moon匹配模式m(o+)n成功
字符串mono匹配模式m(o+)n失败

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

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

2.单个字符匹配

代码：

        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 + "失败");
            }
        }

输出：

字符串ban匹配模式b[aeiou]n成功
字符串ben匹配模式b[aeiou]n成功
字符串bin匹配模式b[aeiou]n成功
字符串bon匹配模式b[aeiou]n成功
字符串bun匹配模式b[aeiou]n成功
字符串byn匹配模式b[aeiou]n失败
字符串baen匹配模式b[aeiou]n失败

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

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

3.多个字符匹配

代码：

        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 + "失败");
            }
        }

输出：

字符串been匹配模式b(ee|ea|oo)n成功
字符串bean匹配模式b(ee|ea|oo)n成功
字符串boon匹配模式b(ee|ea|oo)n成功
字符串buin匹配模式b(ee|ea|oo)n失败
字符串bynn匹配模式b(ee|ea|oo)n失败

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

4.数字匹配

代码：

        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 + "失败");
            }
        }

输出：

字符串1匹配模式d+成功
字符串10匹配模式d+成功
字符串101匹配模式d+成功
字符串1010匹配模式d+成功
字符串100+匹配模式d+失败

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

5.字符数字混合匹配

代码：

        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 + "失败");
            }
        }

输出：

字符串a100匹配模式w+d+成功
字符串b20匹配模式w+d+成功
字符串c30匹配模式w+d+成功
字符串df10000匹配模式w+d+成功
字符串gh0t匹配模式w+d+失败

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

6.通配符^
^表示模式的开始,如^he匹配所有以he开头的字符串.
例程:

        String[] dataArr = { "he", "hero", "here", "hitler" };

        for (String str : dataArr) {
            String patternStr = "(^he)(\w*)";

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

输出：

字符串he匹配模式(^he)(w*)成功
字符串hero匹配模式(^he)(w*)成功
字符串here匹配模式(^he)(w*)成功
字符串hitler匹配模式(^he)(w*)失败

7.通配符$
$表示模式的结束,如ia$匹配所有以ia结尾的单词.

        String[] dataArr = { "ia", "Asia", "China", "Colonbia", "America" };

        for (String str : dataArr) {
            String patternStr = "(\w*)(ia$)";

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

输出：

字符串ia匹配模式(w*)(ia$)成功
字符串Asia匹配模式(w*)(ia$)成功
字符串China匹配模式(w*)(ia$)失败
字符串Colonbia匹配模式(w*)(ia$)成功
字符串America匹配模式(w*)(ia$)失败

8.通配符{}
除了用+表示一次或多次,*表示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 + "失败");
            }
        }

输出：

字符串google匹配模式g(o{2,5})gle成功
字符串gooogle匹配模式g(o{2,5})gle成功
字符串gooooogle匹配模式g(o{2,5})gle成功
字符串goooooogle匹配模式g(o{2,5})gle失败
字符串ggle匹配模式g(o{2,5})gle失败

9.通配符[]中的-
-表示从..到…,如[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 + "失败");
            }
        }

输出：

字符串Tan匹配模式T[a-c]n成功
字符串Tbn匹配模式T[a-c]n成功
字符串Tcn匹配模式T[a-c]n成功
字符串Ton匹配模式T[a-c]n失败
字符串Twn匹配模式T[a-c]n失败

10.使用正则表达式劈分字符串-使用字符串的split方法
例程：

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

输出：

薪水
职位
姓名
年龄
性别

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

11.Pattern的split方法示例
 注意这里要把复杂的模式写在前面,否则简单模式会先匹配上.
代码：

        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);
        }

输出：

职务=GM
薪水=50000
姓名=职业经理人
性别=男
年龄=45

12.使用Pattern劈分字符串

代码：

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

输出：

2007
12
11

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

13.模式类型Pattern.CASE_INSENSITIVE
正则表达式默认都是区分大小写的,使用了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 + "成功");
            }
        }

输出：

字符串ab匹配模式ab成功
字符串Ab匹配模式ab成功
字符串AB匹配模式ab成功

14.使用正则表达式进行字符串替换
代码：

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

输出：

10￥ 1000￥ 10000￥ 100000￥

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

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

15.使用matcher进行替换
代码：

        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());

输出：

替换后内容是moon moon moon moon moon

16.使用Mather验证IP地址的有效性
验证函数:

 public static boolean isValidIpAddr(String ipAddr){
    String regx="(\d+).(\d+).(\d+) .(\d+)";   
    
    if(Pattern.matches(regx, ipAddr)){
      Pattern pattern=Pattern.compile(regx);
      
      Matcher mather=pattern.matcher(ipAddr);
      while(mather.find()){
        for(int i=1;i<=mather.groupCount();i++){
          String str=mather.group(i);
          
          int temp=Integer.parseInt(str);
          
          if(temp>255 || temp<0){
            return false;
          }
        }
      }
    }
    else{
      return false;
    }
    
    return true;
  }

执行语句:

 String[] ipArr = { "1.2.3.4", "3.2.1.5", "999.244.17.200", "233.200.18.20",
        "2.1.0.18", "0.2.1.19" };

    for (String str : ipArr) {
      if (isValidIpAddr(str)) {
        System.out.println(str + "是合法的IP地址");
      } else {
        System.out.println(str + "不是合法的IP地址");
      }
    }

执行结果:

1.2.3.4是合法的IP地址
3.2.1.5是合法的IP地址
999.244.17.200不是合法的IP地址
233.200.18.20是合法的IP地址
2.1.0.18不是合法的IP地址
0.2.1.19不是合法的IP地址

17.XML元素文字解析
代码：

        String regex = "<(\w+)>(\w+)</\1>";
        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));
        }

输出：

Bill
50000
GM

17.1 从HTML中解析文字

HTML文字为：

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
    "http://www.w3.org/TR/html4/strict.dtd">
<html lang="en">
  <head>
    <meta http-equiv="content-type" content="text/html; charset=utf-8">
    <title>GIDC-RTS-NFL36</title>
  </head>
  <body>
GIDC-RTS-NFL36
  </body>
</html>

那么提取body内容的函数为：

    private static String findBodyTextIn(String xml,String node) throws Exception{
        String regex = "<(\w+)>(\s*)((\w|[-])+)(\s*)</\1>";
        Pattern pattern = Pattern.compile(regex);

        Matcher matcher = pattern.matcher(xml);

        while (matcher.find()) {
            if(matcher.group(1).equals(node)){
                return matcher.group(3);
            }
        }
        
        return null;
    }

调用为：

String retval=findBodyTextIn(xml,"body");

结果为：

GIDC-RTS-NFL36

18.将单词和数字部分的单词换成大写

        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());

输出：

替换完的字串为AGE45 SALARY500000 50000 title

19.从字符串“id=1,count=100;id=2,count=300;id=6,count=20;”中解析出id和count值，然后存入一个键和值都为Integer类型的哈希表中。
代码：

        String str="id=1,count=100;id=2,count=300;id=6,count=20;";
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();

        String regex="id=(\d+),count=(\d+);";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while(matcher.find()){
              int id=Integer.parseInt(matcher.group(1));
              int count=Integer.parseInt(matcher.group(2));
              System.out.println("id="+id+" count="+count);
              
              map.put(id, count);
        }

输出：

id=1 count=100
id=2 count=300
id=6 count=20

全文完

2014年8月7日11:31:42