Java中Pattern用法實例(正則表達式)

更新時間：2022年07月07日 09:17:58 作者：woniu317

Pattern在java.util.regex包中,是正則表達式的編譯表示形式,此類的實例是不可變的,可供多個并發(fā)線程安全使用,下面這篇文章主要給大家介紹了關(guān)于Java正則表達式Pattern用法的相關(guān)資料,需要的朋友可以參考下

1. 正則表達式的應(yīng)用

在給用戶發(fā)送消息時通常情況會有相同的消息模板，但其中部分信息跟用戶相關(guān)，因此需要對消息模板中的變量部分進行替換。而對于一個系統(tǒng)而言可能有很多套完全不同的模板。因此需要一個通用的根據(jù)實際信息替換消息模板中變量的方法。消息模板的變量與velcity中的變量規(guī)范相同。

publicstatic <K, V> String replacePlaceHolderWithMapValue(String msg,Map<K,V> placeHolderMap) {
              Patternpattern = Pattern.compile("\\$*!?\\{([\\w]+)\\}");
              Matchermatcher = pattern.matcher(msg);
              Map<String,String> replaceList = new HashMap();
              while(matcher.find()) {
                     StringplaceHolder = matcher.group(0);
                     Stringkey = matcher.group(1);
                     Objectvalue = placeHolderMap.get(key);
                     if(value != null) {
                            replaceList.put(placeHolder,value.toString());
                     }
              }
              for(Entry<String, String> keyValue:replaceList.entrySet()) {
                     msg= msg.replace(keyValue.getKey(), keyValue.getValue());
              }
              returnmsg;
       }

方法中先獲取所有的需要替換的變量存入replaceList中，然后再依次替換。上述方法的正則表達式中，([\\w]+)表示對匹配的內(nèi)容中進行捕獲，捕獲值存入matcher.group中，當(dāng)然也可以有多個捕獲。

2. 常用正則表達式

[abc] a、b 或 c（簡單類）

[^abc] 任何字符，除了 a、b 或 c（否定）

[a-zA-Z] a到 z 或 A 到 Z，兩頭的字母包括在內(nèi)（范圍）

[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]（減去）

. 任何字符（與行結(jié)束符可能匹配也可能不匹配）

\d 數(shù)字：[0-9]

\D 非數(shù)字： [^0-9]

\s 空白字符：[\t\n\x0B\f\r]

\S 非空白字符：[^\s]

\w 單詞字符：[a-zA-Z_0-9]

\W 非單詞字符：[^\w]

\p{Lower} 小寫字母字符：[a-z]

\p{Upper} 大寫字母字符：[A-Z]

X? X，一次或一次也沒有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超過 m 次

(X) X，作為捕獲組

非捕獲

(?=X) X，通過零寬度的正lookahead

(?!X) X，通過零寬度的負(fù)lookahead

(?<=X) X，通過零寬度的正lookbehind

(?<!X) X，通過零寬度的負(fù)lookbehind

(?>X) X，作為獨立的非捕獲組

3 貪婪匹配與懶惰匹配

考慮這個表達式：a.*b，它將會匹配最長的以a開始，以b結(jié)束的字符串。如果用它來搜索aabab的話，它會匹配整個字符串a(chǎn)abab。這被稱為貪婪匹配。

有時，我們更需要懶惰匹配，也就是匹配盡可能少的字符。前面給出的限定符都可以被轉(zhuǎn)化為懶惰匹配模式，只要在它后面加上一個問號?。這樣.*?就意味著匹配任意數(shù)量的重復(fù)，但是在能使整個匹配成功的前提下使用最少的重復(fù)。

a.*?b匹配最短的，以a開始，以b結(jié)束的字符串。如果把它應(yīng)用于aabab的話，它會匹配aab和ab。

public static void main(String[] args) {
        String str = "北京市(海淀區(qū))(朝陽區(qū))";
        String paternStr = ".*(?=\\()";
        Pattern pattern = Pattern.compile(paternStr);
        Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            System.out.println(matcher.group(0));
        }
}

上述方法的輸出為：北京市(海淀區(qū))

public static void main(String[] args) {
        String str = "北京市(海淀區(qū))(朝陽區(qū))";
        String paternStr = ".*？(?=\\()";
        Pattern pattern = Pattern.compile(paternStr);
        Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            System.out.println(matcher.group(0));
        }
}

上述方法輸出：北京市

補充：其它的一些用法

Pattern.split(CharSequence input)

這個方法跟String.split()方法效果類似

Pattern p2 = Pattern.compile("[a-z]+");
// str的長度為2，返回"我愛"和"哈哈"，跟 String[] arr = "我愛java哈哈".
String[] arr = p2.split("我愛java哈哈");
Arrays.stream(arr).forEach(System.out::println);

Pattern.matcher(String regex,CharSequence input)

一個靜態(tài)方法,用于快速匹配字符串,該方法適合用于只匹配一次,且匹配全部字符串，效果與Pattern.compile(regex).matcher(input).matches() 類似

Pattern p = Pattern.compile("\\d+");
// 返回\d+
System.out.println(p.pattern());
// p.pattern()返回\d+， 這里為true，只有當(dāng)全部滿足則為true
System.out.println(Pattern.matches(p.pattern(), "2223"));
// 返回false，只要一個不滿足，則返回false
System.out.println(Pattern.matches(p.pattern(), "2223b"));