java中的正則表達式

1.1 正則表達式

1.2 簡介

Regular Expression  正則表達式   常簡稱為： regex、正則

正則表達式是一整套約束字符串的語法規則，獨立於任何編程語言

正則表達式 方便、靈活、功能強大，多部分編程語言都對正則表達式提供了支持

我們通常把正則作為一個工具，進行字符串的 校驗、獲取、替換等操作

1.2 普通字符和元字符

 

 

正則表達式中，所有字符分為兩類：普通字符和元字符（具有特殊含義的字符）

主要普通字符：小寫字母、大寫字母、數字、下划線、部分特殊符號、非西文字符等

主要元字符：.   \   { }  *   +   ?   ( )   [ ]   -   |   ^   $

.    表示任意一個字符（除了換行符）

\     轉移符，用來改變其他字符的含義，

如：

\元字符          把元字符轉義為普通字符，如\.  把元字符 . 轉義為普通字符的 .

\普通字符      把普通字符轉義為含有特殊含義的字符，如\n 換行符，\r 回車符，\t 制表符

2 java對正則的支持

2.1 Pattern類

Java提供了java.util.regex.Pattern 類來創建正則表達式對象

public  static  boolean  matches(regex, str)  // 用來判斷str是否匹配regex，或者說用來判斷str是否符合regex的要求

 

import java.util.regex.Pattern;

public class RegexTest
{
    public static void main(String[] args)
    {
        String regex = "abc";// 要求字符串為"abc"
        String str = "abc";

        boolean match = Pattern.matches(regex, str);
        System.out.println(match);//輸出true
    }
}

 

2.1.1 元字符的用法

 

易錯點：

1  Java代碼中的 \\ 只表示正則中的 \

2  \n表示換行符，即使用\和n這兩個字符組合在一起表示一個換行字符

 

public static void main(String[] args)
    {
        /*
         String regex = ".";// .在正則中標識任意字符，要求str="任意字符"
        String str = "a";
 
        boolean match = Pattern.matches(regex, str);
        System.out.println(match);//輸出 true
        */        
        
        String regex = "\\.";// 相當於正則中的\.，要求str="."
        String str = "a";
 
        boolean match = Pattern.matches(regex, str);
        System.out.println(match);//輸出 false
    }

 

2.1.2 重復匹配

(x表示一個字符，或者一個字符類，或者一個組等)

x{n}     x連續出現n次

x{n,}    x至少連續出現n次

x{n,m}  x至少連續出現n次，至多連續出現m次

x*      x連續出現0次或多次，等同於x{0,}

x+      x至少連續出現1次，等同於x{1,}

x?      x出現0次或1次，等同於x{0,1}

/* String regex = "a{3}";// 要求a連續出現3次，str="aaa" String str = "a";//false */ /* String regex = "a{3,6}";// 要求a至少連續出現3次，str="aaa.." String str = "aaaaa";//true */ String regex = "a?"; String str = "a";//true boolean match = Pattern.matches(regex, str); System.out.println(match);

2.1.3 選擇匹配

 

使用 |  實現選擇匹配，即多個選項中任選一個

a|b|c          匹配a或者b或者c

red|blue|green    匹配red或者blue或者green

 /*
         String regex = "a|b|c";// str="a" "b" "c"
         String str = "b";//true
*/ 
        String regex = "red|blue|green";// str= "red"或"blue"或"green"
        String str = "blue";//true
 
        boolean match = Pattern.matches(regex, str);
        System.out.println(match);

 

2.1.4 字符類

匹配候選字符的任意一個

[ ]          [abc]   匹配abc中任意一個字符，類似 a|b|c

[^ ]        [^abc]   匹配非abc的任意一個字符

[ - ]        [0-9]、[a-z]、[a-zA-Z]   匹配范圍內的任意一個字符

注意：字符類中的元字符（\除外），會被自動轉義為普通字符，比如 [.]  等同於  [\.]

\w    代表一個單詞字符，類似於[a-zA-Z0-9_]，有的語言中也可以匹配中文

\W   代表一個非單詞字符，類似於[^a-zA-Z0-9_]

\d    代表一個數字字符，等同於[0-9]

\D    代表一個非數字字符，等同於[^0-9]

\s    代表一個空白字符

\S    代表一個非空白字符

 

  // String regex = "hello[abc]";// str="helloa" "hellob" "helloc" // String regex = "[0-9]";// str="0" "1"..."9" 

2.2 Matcher類

 

Java還提供了 java.util.regex.Matcher  匹配器類，用來支持復雜的正則操作

Matcher matcher = Pattern.compile(regex).matcher(str);

boolean find = matcher.find();// 查找str中是否有下一個匹配regex的子字符串

String group = matcher.group();// 返回當前和regex匹配的子字符串

//典型用法

while (matcher.find()) {

       String substr = matcher.group();

       // ...

}

貪婪匹配：在重復匹配時，默認會匹配盡可能多的字符

非貪婪匹配：在重復匹配后面加上?問號，會匹配盡可能少的字符(並不嚴格)

 

public static void main(String[] args) {
 
        // String regex = "ab";// 要求str的子字符串substr="ab"
        // String str = "xabxxabmmabx";
 
        //打印出一個字符串里面的所有的qq郵箱
        String regex = "[1-9][0-9]{4,}@qq.com";// qq郵箱的正則表達式寫法
        String str = "[e-mail][e-mail][e-mail]";
 
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
 
        while (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }
    }

 

輸出：

[e-mail] [e-mail] [e-mail]

2.2.1 貪婪匹配和非貪婪匹配

貪婪匹配：在重復匹配時，默認會匹配盡可能多的字符。這也是正則中默認的匹配模式。

非貪婪匹配：在重復匹配后面加上?問號，會匹配盡可能少的字符(並不嚴格)

 

注意下面三處代碼的不同

1.

String regex = "[1-9][0-9]{4,}";// qq郵箱的正則表達式寫法
        String str = "[e-mail][e-mail][e-mail]";
 
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
 
        while (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }

 

輸出：

12345
123456
1234567

2.

String regex = "[1-9][0-9]{4,}?";// qq郵箱的正則表達式寫法
        String str = "[e-mail][e-mail][e-mail]";
 
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
 
        while (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }

 

輸出：

12345
12345
12345

3.

String regex = "[1-9][0-9]{4,}@qq.com";// qq郵箱的正則表達式寫法
        String str = "[e-mail][e-mail][e-mail]";
 
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
 
        while (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }

 

輸出：

[e-mail] [e-mail] [e-mail]

2.3 String支持正則操作的方法

由於正則表達式和字符串如此相關，Java就為 java.lang.String 字符串類提供了若干可以直接進行正則操作的方法。

這里有個小技巧，String的方法中參數為regex的都是支持正則的。

//使用replacement替換全部匹配regex的子字符串

String newStr = str.replaceAll(regex, replacement);

String[] newStrs = str.split(regex);//使用regex作為分隔符切分str

boolean match = str.matches(regex);// 等同於Pattern.matches(regex, str)

   String str="0123456789"; System.out.println(str.replaceAll("[0-9]", "*")); System.out.println("--------------------------------------"); String str2="apple12orange84745banana666hello"; String[] parts = str2.split("[0-9]+"); System.out.println(Arrays.toString(parts));

輸出：

********** -------------------------------------- [apple, orange, banana, hello]