從制造到創(chuàng)造
          軟件工程師成長之路
          posts - 292,  comments - 96,  trackbacks - 0
          在String類中,有四個特殊的方法:


          public String[] split(String regex)
          根據(jù)給定的正則表達(dá)式的匹配來拆分此字符串。

          該方法的作用就像是使用給定的表達(dá)式和限制參數(shù) 0 來調(diào)用兩參數(shù) split 方法。因此,結(jié)果數(shù)組中不包括結(jié)尾空字符串。

          例如,字符串 "boo:and:foo" 產(chǎn)生帶有下面這些表達(dá)式的結(jié)果:

          Regex 結(jié)果
          : { "boo", "and", "foo" }
          o { "b", "", ":and:f" }
          參數(shù): regex - 定界正則表達(dá)式
          返回: 字符串?dāng)?shù)組,根據(jù)給定正則表達(dá)式的匹配來拆分此字符串,從而生成此數(shù)組。
          拋出: PatternSyntaxException - 如果正則表達(dá)式的語法無效

          public String[] split(String regex, int limit)
          根據(jù)匹配給定的正則表達(dá)式來拆分此字符串。

          此方法返回的數(shù)組包含此字符串的每個子字符串,這些子字符串由另一個匹配給定的表達(dá)式的子字符串終止或由字符串結(jié)束來終止。數(shù)組中的子字符串按它們在此字符串中的順序排列。如果表達(dá)式不匹配輸入的任何部分,則結(jié)果數(shù)組只具有一個元素,即此字符串。

          limit 參數(shù)控制模式應(yīng)用的次數(shù),因此影響結(jié)果數(shù)組的長度。如果該限制 n 大于 0,則模式將被最多應(yīng)用 n - 1 次,數(shù)組的長度將不會大于 n,而且數(shù)組的最后項(xiàng)將包含超出最后匹配的定界符的所有輸入。如果 n 為非正,則模式將被應(yīng)用盡可能多的次數(shù),而且數(shù)組可以是任意長度。如果 n 為零,則模式將被應(yīng)用盡可能多的次數(shù),數(shù)組可有任何長度,并且結(jié)尾空字符串將被丟棄。

          例如,字符串 "boo:and:foo" 使用這些參數(shù)可生成下列結(jié)果:

          Regex Limit 結(jié)果
          : 2 { "boo", "and:foo" }
          : 5 { "boo", "and", "foo" }
          : -2 { "boo", "and", "foo" }
          o 5 { "b", "", ":and:f", "", "" }
          o -2 { "b", "", ":and:f", "", "" }
          o 0 { "b", "", ":and:f" }

          這種形式的方法調(diào)用 str.split(regex, n) 產(chǎn)生與以下表達(dá)式完全相同的結(jié)果:

          Pattern.compile(regex).split(str, n)

          參數(shù): regex - 定界正則表達(dá)式 ;limit - 結(jié)果閾值,如上所述

          返回: 字符串?dāng)?shù)組,根據(jù)給定正則表達(dá)式的匹配來拆分此字符串,從而生成此數(shù)組

          public String replaceAll(String regex, String replacement)
          使用給定的 replacement 字符串替換此字符串匹配給定的正則表達(dá)式的每個子字符串。

          此方法調(diào)用的 str.replaceAll(regex, repl) 形式產(chǎn)生與以下表達(dá)式完全相同的結(jié)果:

          Pattern.compile(regex).matcher(str).replaceAll(repl)

          參數(shù): regex - 用來匹配此字符串的正則表達(dá)式

          返回: 得到的 String

          public String replaceFirst(String regex, String replacement)
          使用給定的 replacement 字符串替換此字符串匹配給定的正則表達(dá)式的第一個子字符串。

          此方法調(diào)用的 str.replaceFirst(regex, repl) 形式產(chǎn)生與以下表達(dá)式完全相同的結(jié)果:

          Pattern.compile(regex).matcher(str).replaceFirst(repl)

          參數(shù):regex - 用來匹配此字符串的正則表達(dá)式

          返回: 得到的 String

          這四個方法中都有一個參數(shù)為正則表達(dá)式(Regular Expression),而不是普通的字符串。

          在正則表達(dá)式中具有特殊含義的字符

          特殊字符

          描述

              .     表示任意一個字符
              [abc]     表示a、b或c中的任意一個字符
              [^abc]     除a、b和c以外的任意一個字符
              [a-zA-z]     介于a到z,或A到Z中的任意一個字符
              \s     空白符(空格、tab、換行、換頁、回車)
              \S     非空白符
              \d     任意一個數(shù)字[0-9]
              \D     任意一個非數(shù)字[^0-9]
              \w     詞字符[a-zA-Z_0-9]
              \W     非詞字符

          表示字符出現(xiàn)次數(shù)的符號

          表示次數(shù)的符號

          描述

              *     0 次或者多次
              +     1 次或者多次
              ?     0 次或者 1 次
              {n}     恰好 n 次
              {n, m}     至少 n 次,不多于 m 次


          public class RegDemo2 {

              
          /**
               * 
          @param args
               
          */
              
          public static void main(String[] args) {
                  
          // 例如,字符串 "boo:and:foo" 產(chǎn)生帶有下面這些表達(dá)式的結(jié)果: Regex 結(jié)果
                  
          // : { "boo", "and", "foo" }
                  
          // o { "b", "", ":and:f" }
                  String tempStr = "boo:and:foo";
                  String[] a 
          = tempStr.split(":");        
                  pringStringArray(a);
                  
                  String[] b 
          = tempStr.split("o");
                  pringStringArray(b);
                  
                  System.out.println(
          "--------------------------");
                  
                  
          // Regex Limit 結(jié)果
                  
          // : 2 { "boo", "and:foo" }
                  
          // : 5 { "boo", "and", "foo" }
                  
          // : -2 { "boo", "and", "foo" }
                  
          // o 5 { "b", "", ":and:f", "", "" }
                  
          // o -2 { "b", "", ":and:f", "", "" }
                  
          // o 0 { "b", "", ":and:f" }
                  pringStringArray(tempStr.split(":"2));
                  pringStringArray(tempStr.split(
          ":"5));
                  pringStringArray(tempStr.split(
          ":"-2));
                  pringStringArray(tempStr.split(
          "o"5));
                  pringStringArray(tempStr.split(
          "o"-2));
                  pringStringArray(tempStr.split(
          "o"0));

                  
          // 字符串 "boo:and:foo"中的所有“:”都被替換為“XX”,輸出:booXXandXXfoo
                  System.out.println(tempStr.replaceAll(":""XX"));
                  
                  
          // 字符串 "boo:and:foo"中的第一個“:”都被替換為“XX”,輸出: booXXand:foo
                  System.out.println(tempStr.replaceFirst(":""XX"));
              }

              
          public static void pringStringArray(String[] s) {
                  
          int index = s.length;
                  
          for (int i = 0; i < index; i++) {
                      System.err.println(i 
          + "" + s[i]);
                  }
              }
          }

          下面的程序演示了正則表達(dá)式的用法:
          /**
           * discription:
           * 
           * 
          @author CoderDream
           * 
           
          */
          public class RegularExTester {

              
          /**
               * 
          @param args
               
          */
              
          public static void main(String[] args) {
                  
          // 把字符串中的“aaa”全部替換為“z”,打印:zbzcz
                  System.out.println("aaabaaacaaa".replaceAll("a{3}""z"));

                  
          // 把字符串中的“aaa”、“aa”或者“a”全部替換為“*”,打印:*b*c*
                  System.out.println("aaabaaca".replaceAll("a{1,3}""\\*"));

                  
          // 把字符串中的數(shù)字全部替換為“z”,打印:zzzazzbzzcc
                  System.out.println("123a44b35cc".replaceAll("\\d""z"));

                  
          // 把字符串中的非數(shù)字全部替換為“0”,打印:1234000435000
                  System.out.println("1234abc435def".replaceAll("\\D""0"));

                  
          // 把字符串中的“.”全部替換為“\”,打印:com\abc\dollapp\Doll
                  System.out.println("com.abc.dollapp.Doll".replaceAll("\\.""\\\\"));

                  
          // 把字符串中的“a.b”全部替換為“_”,
                  
          // “a.b”表示長度為3的字符串,以“a”開頭,以“b”結(jié)尾
                  
          // 打印:-hello-all
                  System.out.println("azbhelloahball".replaceAll("a.b""-"));

                  
          // 把字符串中的所有詞字符替換為“#”
                  
          // 正則表達(dá)式“[a-zA-z_0-9]”等價于“\w”
                  
          // 打印:#.#.#.#.#.#
                  System.out.println("a.b.c.1.2.3.4".replaceAll("[a-zA-z_0-9]""#"));
                  System.out.println(
          "a.b.c.1.2.3.4".replaceAll("\\w""#"));
              }
          }

          值得注意的是,由于“.”、“?”和“*”等在正則表達(dá)式中具有特殊的含義,如果要表示字面上的這些字符,必須以“\\”開頭。例如為了把字符串“com.abc.dollapp.Doll”中的“.”替換為“\”,應(yīng)該調(diào)用replaceAll("\\.",\\\\)方法。

          Java中的正則表達(dá)式類


           public interface MatchResult

          
              

          匹配操作的結(jié)果。

          此接口包含用于確定與正則表達(dá)式匹配結(jié)果的查詢方法。通過 MatchResult 可以查看匹配邊界、組和組邊界,但是不能修改


           public final class Matcher

          extends Object
          implements MatchResult
          
              

          通過解釋 Pattern字符序列 執(zhí)行匹配操作的引擎。

          通過調(diào)用模式的 matcher 方法從模式創(chuàng)建匹配器。創(chuàng)建匹配器后,可以使用它執(zhí)行三種不同的匹配操作:

          • matches 方法嘗試將整個輸入序列與該模式匹配。

          • lookingAt 嘗試將輸入序列從頭開始與該模式匹配。

          • find 方法掃描輸入序列以查找與該模式匹配的下一個子序列。

          每個方法都返回一個表示成功或失敗的布爾值。通過查詢匹配器的狀態(tài)可以獲取關(guān)于成功匹配的更多信息。


           public final class Pattern

          extends Object
          implements Serializable
          
              

          正則表達(dá)式的編譯表示形式。

          指定為字符串的正則表達(dá)式必須首先被編譯為此類的實(shí)例。然后,可將得到的模式用于創(chuàng)建 Matcher 對象,依照正則表達(dá)式,該對象可以與任意字符序列匹配。執(zhí)行匹配所涉及的所有狀態(tài)都駐留在匹配器中,所以多個匹配器可以共享同一模式。

          因此,典型的調(diào)用順序是

           Pattern p = Pattern.matches();

          在僅使用一次正則表達(dá)式時,可以方便地通過此類定義 matches 方法。此方法編譯表達(dá)式并在單個調(diào)用中將輸入序列與其匹配。語句

           boolean b = Pattern.matches("a*b", "aaaaab");

          等效于上面的三個語句,盡管對于重復(fù)的匹配而言它效率不高,因?yàn)樗辉试S重用已編譯的模式。

          此類的實(shí)例是不可變的,可供多個并發(fā)線程安全使用。Matcher 類的實(shí)例用于此目的則不安全。


          測試代碼:

          /**
           * discription:Java中正則表達(dá)式類的使用
           * 
           * 
          @author CoderDream
           * 
           
          */
          public class RegDemo {

              
          /**
               * 
          @param args
               
          */
              
          public static void main(String[] args) {
                  
          // 檢查字符串中是否含有“aaa”,有返回:true,無返回:false
                  System.out.println(isHaveBeenSetting("a{3}""aaabaaacaaa"));
                  System.out.println(isHaveBeenSetting(
          "a{3}""aab"));
                  
                  
          // 把字符串“abbaaacbaaaab”中的“aaa”全部替換為“z”,打印:abbzbza
                  System.out.println(replaceStr("a{3}""abbaaabaaaa""z"));
              }

              
          /**
               * 
               * 
          @param regEx
               *            設(shè)定的正則表達(dá)式
               * 
          @param tempStr
               *            系統(tǒng)參數(shù)中的設(shè)定的字符串
               * 
          @return 是否系統(tǒng)參數(shù)中的設(shè)定的字符串含有設(shè)定的正則表達(dá)式 如果有的則返回true
               
          */
              
          public static boolean isHaveBeenSetting(String regEx, String tempStr) {
                  
          boolean result = false;
                  
          try {
                      Pattern p 
          = Pattern.compile(regEx);
                      Matcher m 
          = p.matcher(tempStr);
                      result 
          = m.find();
                  } 
          catch (Exception e) {
                      e.printStackTrace();
                  }
                  
          return result;
              }

              
          /**
               * 將字符串含有的regEx表達(dá)式替換為replaceRegEx
               * 
               * 
          @param regEx
               *            需要被替換的正則表達(dá)式
               * 
          @param tempStr
               *            替換的字符串
               * 
          @param replaceRegEx
               *            替換的正則表達(dá)式
               * 
          @return 替換好后的字符串
               
          */
              
          public static String replaceStr(String regEx, String tempStr,
                      String replaceRegEx) {
                  Pattern p 
          = Pattern.compile(regEx);
                  Matcher m 
          = p.matcher(tempStr);
                  tempStr 
          = m.replaceAll(replaceRegEx);

                  
          return tempStr;
              }
          }
          posted on 2008-02-28 11:40 CoderDream 閱讀(2346) 評論(0)  編輯  收藏 所屬分類: 學(xué)習(xí)筆記

          <2008年2月>
          272829303112
          3456789
          10111213141516
          17181920212223
          2425262728291
          2345678

          常用鏈接

          留言簿(9)

          我參與的團(tuán)隊

          隨筆分類(245)

          隨筆檔案(239)

          文章分類(3)

          文章檔案(3)

          收藏夾(576)

          友情鏈接

          搜索

          •  

          積分與排名

          • 積分 - 458376
          • 排名 - 114

          最新評論

          閱讀排行榜

          評論排行榜

          主站蜘蛛池模板: 曲麻莱县| 松溪县| 卓资县| 迁安市| 会同县| 平定县| 涟水县| 永定县| 博罗县| 珠海市| 岐山县| 德保县| 高要市| 道孚县| 南平市| 军事| 从化市| 昌图县| 清镇市| 龙口市| 沧源| 长泰县| 龙州县| 师宗县| 江山市| 巴中市| 临海市| 桂阳县| 富平县| 锡林浩特市| 湛江市| 浪卡子县| 清水河县| 惠州市| 宜黄县| 铅山县| 吴江市| 邵武市| 东乌| 盐亭县| 巴东县|