JAVA正則表達式範例

package com.simple.zhengze;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
   public static void main(String args[]) {
//     zhengZe0();
//     zhengZe1();
//     zhengZe2();
//     zhengZe3();
//     zhengZeExample1();
//     zhengZeExample2();
//     zhengZeExample3();
//     zhengZeExample4();
//     zhengZeExample6();
//     zhengZeExample7();
//     zhengZeExample8();
//     zhengZeExample9();
//     zhengZeExample10();
//     zhengZeExample11();
//     zhengZeExample12();
//     zhengZeExample13();
//     zhengZeExample14();
     zhengZeExample15();
//     zhengZeExample16();
  }

   /**
    * 例子程序： 替換字符串中的以"["開頭，以"]"結尾的字符 還包括|
    */
   public static void zhengZe0() {
    String str = " [單式]    1,1,8,8,1,4:11|[單式]    1,0,0,0,0,2:01|[單式]    7,5,3,3,2,5:12|[單式]    0,6,3,9,6,8:10|[單式]    8,6,8,1,9,8:05";
    Pattern pattern = Pattern.compile( "\\|?\\[\\S*\\]");
    Matcher matcher = pattern.matcher(str);

    System.out.println(matcher.replaceAll(""));
  }
   /**
    * 例子程序： 替換字符串中的以"["開頭，以"]"結尾的字符 還包括先後的空格也都被替換掉
    */
   public static void zhengZe1() {
    String str = " [單式]    1,1,8,8,1,4:11|[單式]    1,0,0,0,0,2:01|[單式]    7,5,3,3,2,5:12|[單式]    0,6,3,9,6,8:10|[單式]    8,6,8,1,9,8:05";
    Pattern pattern = Pattern.compile( "\\s*\\|?\\[\\S*\\]\\s*");
    Matcher matcher = pattern.matcher(str);

    System.out.println(matcher.replaceAll( " "));
  }
   /**
    * 例子程序： 判斷該字符串是否是以 "head" 開頭，以 "end" 結尾
    */
   public static void zhengZe2() {
    String regexp = "^head\\sbody\\s*end$";
    String str = "head body    end";
    Pattern pattern = Pattern.compile(regexp);
    Matcher matcher = pattern.matcher(str);
    System.out.println(matcher.matches());

  }
   /**
    * 例子程序：    
    */
   public static void zhengZe3() {
    String str = " [單式]    1,1,8,8,1,4:11|[單式]    1,0,0,0,0,2:01|[單式]    7,5,3,3,2,5:12|[單式]    0,6,3,9,6,8:10|[單式]    8,6,8,1,9,8:05";
    Pattern pattern = Pattern.compile( "\\s*\\|?\\[\\S*\\]\\s*");
    Matcher matcher = pattern.matcher(str);

    System.out.println(matcher.matches());
  }

   /**
    * 正則式是最簡單的能準確匹配一個給定String的模式,模式與要匹配的文本是等價的.靜態的Pattern.matches方法用於比較一個String是否匹配一個給定模式.例程以下:
    */
   public static void zhengZeExample1() {
    String data = " java    ";
     boolean result = Pattern.matches( "^\\s*java\\s*$", data);
    System.out.println(result);
  }

   /**
    * 模式是」m(o+)n」,它表示mn中間的o能夠重複一次或屢次,所以moon,mon,mooon能匹配成功,而mono在n後多了一個o,和模式匹配不上.
    * 注: +表示一次或屢次;?表示0次或一次;*表示0次或屢次.
    */
   public static void zhengZeExample2() {
    String[] dataArr = { "moon", "mon", "mn", "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 + "失敗");
      }
    }
  }

   /**
    * 注:方括號中只容許的單個字符,模式「b[aeiou]n」指定,只有以b開頭,n結尾,中間是a,e,i,o,u中任意一個的才能匹配上,因此數組的前五個能夠匹配,後兩個元素沒法匹配.
    * 方括號[]表示只有其中指定的字符才能匹配.
    */
   public static void zhengZeExample3() {
    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(ee|ea|oo)n就能匹配been,bean,boon等.
    * 所以前三個能匹配上,然後兩個不能.
    */
   public static void zhengZeExample4() {
    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 + "失敗");
      }
    }

  }

   /**
    * 模式\w+\d+表示的是以多個單字字符開頭,多個數字結尾的字符串,所以前四個能匹配上,最後一個由於數字後還含有單字字符而不能匹配
    */
   public static void zhengZeExample6() {
    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 + "失敗");
      }
    }
  }

   /**
    * String類的split函數支持正則表達式,上例中模式能匹配」,」,單個空格,」;」中的一個,split函數能把它們中任意一個看成分隔符,將一個字符串劈分紅字符串數組
    */
   public static void zhengZeExample7() {
    String str = "薪水,職位 姓名;年齡 性別";
    String[] dataArr = str.split( "[,\\s;]");
     for (String strTmp : dataArr) {
      System.out.println(strTmp);
    }
  }

   /**
    * Pattern是一個正則表達式經編譯後的表現模式 ,它的split方法能有效劈分字符串.注意其和String.split()使用上的不一樣.
    */
   public static void zhengZeExample8() {
    String str = "2007年12月11日";
    Pattern p = Pattern.compile( "[年月日]");
    String[] dataArr = p.split(str);
     for (String strTmp : dataArr) {
      System.out.print(strTmp);
    }
  }

   /**
    * 上例中,模式「(\d+)(元|人民幣|RMB)」按括號分紅了兩組,第一組\d+匹配單個或多個數字,第二組匹配元,人民幣,RMB中的任意一個,替換部分表示第一個組匹配的部分不變,其他組替換成￥.
    *    
    * 替換後的str爲￥10 ￥1000 ￥10000 ￥100000
    *    
    */
   public static void zhengZeExample9() {
    String str = "10元 1000人民幣 10000元 100000RMB";
    str = str.replaceAll( "(^|\\s+)", "￥");
    System.out.println(str);
    str = str.replaceAll( "(元|人民幣|RMB)", "");
    System.out.println(str);
  }

   /**
    * System.out.println("替換後內容是" + sb.toString());
    */
   public static void zhengZeExample10() {
    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次.
    */
   public static void zhengZeExample11() {
    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 + "失敗");
      }
    }
  }

   public static void zhengZeExample12() {
    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則不對大小寫進行區分.
    */
   public static void zhengZeExample13() {
    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 + "成功");
      }
    }
  }

   /**
    * 注意這裏要把複雜的模式寫在前面,不然簡單模式會先匹配上.
    */
   public static void zhengZeExample14() {
    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.
    */
   public static void zhengZeExample15() {
    String regex = "<(\\w+)>(\\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(1) + ":" + matcher.group(2));
    }
  }
   /**
    * 將單詞數字混合的字符串的單詞部分大寫.
    */
   public static void zhengZeExample16() {
    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());   } }