Java 正則表達式詳解

時間 2019-11-08

標籤 java 正則表達式詳解欄目 Java 简体版

原文原文鏈接

版權聲明：本文由 吳仙傑創做整理，轉載請註明出處： http://www.javashuo.com/article/p-rwufmavd-t.html

1. 正則表達式

1.1 什麼是正則表達式

正則表達式
: 定義一個搜索模式的字符串。javascript

正則表達式能夠用於搜索、編輯和操做文本。html

正則對文本的分析或修改過程爲：首先正則表達式應用的是文本字符串（text/string），它會以定義的模式從左到右匹配文本，每一個源字符只匹配一次。java

1.2 示例

正則表達式	匹配
`this is text`	精確匹配字符串 "this is text"
`this\s+is\s+text`	匹配單詞 "this" 後跟一個或多個空格字符，後跟詞 "is" 後跟一個或多個空格字符，後跟詞 "text"
`^\d+(\.\d+)?`	`^` 定義模式必須匹配字符串的開始，`d+` 匹配一個或多個數字，`?` 代表小括號內的語句是可選的，`\.` 匹配 "."，小括號表示分組。例如匹配："5"、"1.5" 和 "2.21"

2. 正則表達式的編寫規則

2.1 常見匹配符號

正則表達式	描述
`.`	匹配全部單個字符，除了換行符（Linux 中換行是 `\n`，Windows 中換行是 `\r\n`）
`^regex`	正則必須匹配字符串開頭
`regex$`	正則必須匹配字符串結尾
`[abc]`	複選集定義，匹配字母 a 或 b 或 c
`[abc][vz]`	複選集定義，匹配字母 a 或 b 或 c，後面跟着 v 或 z
`[^abc]`	當插入符 `^` 在中括號中以第一個字符開始顯示，則表示否認模式。此模式匹配全部字符，除了 a 或 b 或 c
`[a-d1-7]`	範圍匹配，匹配字母 a 到 d 和數字從 1 到 7 之間，但不匹配 d1
`XZ`	匹配 X 後直接跟着 Z
X\|Z	匹配 X 或 Z

2.2 元字符

元字符是一個預約義的字符。正則表達式

正則表達式	描述
`\d`	匹配一個數字，是 `[0-9]` 的簡寫
`\D`	匹配一個非數字，是 `[^0-9]` 的簡寫
`\s`	匹配一個空格，是 `[ \t\n\x0b\r\f]` 的簡寫
`\S`	匹配一個非空格
`\w`	匹配一個單詞字符（大小寫字母、數字、下劃線），是 `[a-zA-Z_0-9]` 的簡寫
`\W`	匹配一個非單詞字符（除了大小寫字母、數字、下劃線以外的字符），等同於 `[^\w]`

2.3 限定符

限定符定義了一個元素能夠發生的頻率。shell

正則表達式	描述	舉例
`*`	匹配 >=0 個，是 `{0,}` 的簡寫	`X` 表示匹配零個或多個字母 X，`.` 表示匹配任何字符串
`+`	匹配 >=1 個，是 `{1,}` 的簡寫	`X+` 表示匹配一個或多個字母 X
`?`	匹配 1 個或 0 個，是 `{0,1}` 的簡寫	`X?` 表示匹配 0 個或 1 個字母 X
`{X}`	只匹配 X 個字符	`\d{3}` 表示匹配 3 個數字，`.{10}` 表示匹配任何長度是 10 的字符串
`{X,Y}`	匹配 >=X 且 <=Y 個	`\d{1,4}` 表示匹配至少 1 個最多 4 個數字
`*?`	若是 `?` 是限定符 `` 或 `+` 或 `?` 或 `{}` 後面的第一個字符，那麼表示非貪婪模式（儘量少的匹配字符），而不是默認的貪婪模式*

2.4 分組和反向引用

小括號 () 能夠達到對正則表達式進行分組的效果。express

模式分組後會在正則表達式中建立反向引用。反向引用會保存匹配模式分組的字符串片段，這使得咱們能夠獲取並使用這個字符串片段。segmentfault

在以正則表達式替換字符串的語法中，是經過 $ 來引用分組的反向引用，$0 是匹配完整模式的字符串（注意在 JavaScript 中是用 $& 表示）；$1 是第一個分組的反向引用；$2 是第二個分組的反向引用，以此類推。工具

示例：測試

package com.wuxianjiezh.demo.regex;

public class RegexTest {

    public static void main(String[] args) {
        // 去除單詞與 , 和 . 之間的空格
        String Str = "Hello , World .";
        String pattern = "(\\w)(\\s+)([.,])";
        // $0 匹配 `(\w)(\s+)([.,])` 結果爲 `o空格,` 和 `d空格.`
        // $1 匹配 `(\w)` 結果爲 `o` 和 `d`
        // $2 匹配 `(\s+)` 結果爲 `空格` 和 `空格`
        // $3 匹配 `([.,])` 結果爲 `,` 和 `.`
        System.out.println(Str.replaceAll(pattern, "$1$3")); // Hello, World.
    }
}

上面的例子中，咱們使用了 [.] 來匹配普通字符 . 而不須要使用 [\\.]。由於正則對於 [] 中的 .，會自動處理爲 [\.]，即普通字符 . 進行匹配。this

2.4.1 僅分組但無反向引用

當咱們在小括號 () 內的模式開頭加入 ?:，那麼表示這個模式僅分組，但不建立反向引用。

示例：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "img.jpg";
        // 分組且建立反向引用
        Pattern pattern = Pattern.compile("(jpg|png)");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group());
            System.out.println(matcher.group(1));
        }
    }
}

運行結果：

jpg
jpg

若源碼改成：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "img.jpg";
        // 分組但不建立反向引用
        Pattern pattern = Pattern.compile("(?:jpg|png)");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group());
            System.out.println(matcher.group(1));
        }
    }
}

運行結果：

jpg
Exception in thread "main" java.lang.IndexOutOfBoundsException: No group 1
    at java.util.regex.Matcher.group(Matcher.java:538)
    at com.wuxianjiezh.regex.RegexTest.main(RegexTest.java:15)

2.4.2 分組的反向引用副本

Java 中能夠在小括號中使用 ?<name> 將小括號中匹配的內容保存爲一個名字爲 name 的副本。

示例：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "@wxj 你好啊";
        Pattern pattern = Pattern.compile("@(?<first>\\w+\\s)"); // 保存一個副本
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group());
            System.out.println(matcher.group(1));
            System.out.println(matcher.group("first"));
        }
    }
}

運行結果：

@wxj 
wxj 
wxj

2.5 否認先行斷言（Negative lookahead）

咱們能夠建立否認先行斷言模式的匹配，即某個字符串後面不包含另外一個字符串的匹配模式。

否認先行斷言模式經過 (?!pattern) 定義。好比，咱們匹配後面不是跟着 "b" 的 "a"：

a(?!b)

2.6 指定正則表達式的模式

能夠在正則的開頭指定模式修飾符。

(?i) 使正則忽略大小寫。
(?s) 表示單行模式（"single line mode"）使正則的 . 匹配全部字符，包括換行符。
(?m) 表示多行模式（"multi-line mode"），使正則的 ^ 和 $ 匹配字符串中每行的開始和結束。

2.7 Java 中的反斜槓

反斜槓 \ 在 Java 中表示轉義字符，這意味着 \ 在 Java 擁有預約義的含義。

這裏例舉兩個特別重要的用法：

在匹配 . 或 { 或 [ 或 ( 或 ? 或 $ 或 ^ 或 * 這些特殊字符時，須要在前面加上 \\，好比匹配 . 時，Java 中要寫爲 \\.，但對於正則表達式來講就是 \.。
在匹配 \ 時，Java 中要寫爲 \\\\，但對於正則表達式來講就是 \\。

注意：Java 中的正則表達式字符串有兩層含義，首先 Java 字符串轉義出符合正則表達式語法的字符串，而後再由轉義後的正則表達式進行模式匹配。

2.8 易錯點示例

[jpg|png] 表明匹配 j 或 p 或 g 或 p 或 n 或 g 中的任意一個字符。
(jpg|png) 表明匹配 jpg 或 png。

3. 在字符串中使用正則表達式

3.1 內置的字符串正則處理方法

在 Java 中有四個內置的運行正則表達式的方法，分別是 matches()、split())、replaceFirst()、replaceAll()。注意 replace() 方法不支持正則表達式。

方法	描述
`s.matches("regex")`	當僅且當正則匹配整個字符串時返回 `true`
`s.split("regex")`	按匹配的正則表達式切片字符串
`s.replaceFirst("regex", "replacement")`	替換首次匹配的字符串片斷
`s.replaceAll("regex", "replacement")`	替換全部匹配的字符

3.2 示例

示例代碼：

package com.wuxianjiezh.regex;

public class RegexTest {

    public static void main(String[] args) {
        System.out.println("wxj".matches("wxj"));
        System.out.println("----------");

        String[] array = "w x j".split("\\s");
        for (String item : array) {
            System.out.println(item);
        }
        System.out.println("----------");

        System.out.println("w x j".replaceFirst("\\s", "-"));
        System.out.println("----------");

        System.out.println("w x j".replaceAll("\\s", "-"));
    }
}

運行結果：

true
----------
w
x
j
----------
w-x j
----------
w-x-j

4. 模式和匹配

Java 中使用正則表達式須要用到兩個類，分別爲 java.util.regex.Pattern 和 java.util.regex.Matcher。

第一步，經過正則表達式建立模式對象 Pattern。

第二步，經過模式對象 Pattern，根據指定字符串建立匹配對象 Matcher。

第三步，經過匹配對象 Matcher，根據正則表達式操做字符串。

來個例子，加深理解：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String text = "Hello Regex!";

        Pattern pattern = Pattern.compile("\\w+");
        // Java 中忽略大小寫，有兩種寫法：
        // Pattern pattern = Pattern.compile("\\w+", Pattern.CASE_INSENSITIVE);
        // Pattern pattern = Pattern.compile("(?i)\\w+"); // 推薦寫法
        Matcher matcher = pattern.matcher(text);
        // 遍例全部匹配的序列
        while (matcher.find()) {
            System.out.print("Start index: " + matcher.start());
            System.out.print(" End index: " + matcher.end() + " ");
            System.out.println(matcher.group());
        }
        // 建立第兩個模式，將空格替換爲 tab
        Pattern replace = Pattern.compile("\\s+");
        Matcher matcher2 = replace.matcher(text);
        System.out.println(matcher2.replaceAll("\t"));
    }
}

運行結果：

Start index: 0 End index: 5 Hello
Start index: 6 End index: 11 Regex
Hello    Regex!

5. 若干個經常使用例子

5.1 中文的匹配

[\u4e00-\u9fa5]+ 表明匹配中文字。

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "閑人到人間";
        Pattern pattern = Pattern.compile("[\\u4e00-\\u9fa5]+");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

運行結果：

閑人到人間

5.2 數字範圍的匹配

好比，匹配 1990 到 2017。

注意：這裏有個新手易範的錯誤，就是正則 [1990-2017]，實際這個正則只匹配 0 或 1 或 2 或 7 或 9 中的任一個字符。

正則表達式匹配數字範圍時，首先要肯定最大值與最小值，最後寫中間值。

正確的匹配方式：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "1990\n2010\n2017";
        // 這裏應用了 (?m) 的多行匹配模式，只爲方便咱們測試輸出
        // "^1990$|^199[1-9]$|^20[0-1][0-6]$|^2017$" 爲判斷 1990-2017 正確的正則表達式
        Pattern pattern = Pattern.compile("(?m)^1990$|^199[1-9]$|^20[0-1][0-6]$|^2017$");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

運行結果：

1990
2010
2017

5.3 img 標籤的匹配

好比，獲取圖片文件內容，這裏咱們考慮了一些不規範的 img 標籤寫法：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "<img  src='aaa.jpg' /><img src=bbb.png/><img src=\"ccc.png\"/>" +
                "<img src='ddd.exe'/><img src='eee.jpn'/>";
        // 這裏咱們考慮了一些不規範的 img 標籤寫法，好比：空格、引號
        Pattern pattern = Pattern.compile("<img\\s+src=(?:['\"])?(?<src>\\w+.(jpg|png))(?:['\"])?\\s*/>");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group("src"));
        }
    }
}

運行結果：

aaa.jpg
bbb.png
ccc.png

5.4 貪婪與非貪婪模式的匹配

好比，獲取 div 標籤中的文本內容：

package com.wuxianjiezh.regex;

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

public class RegexTest {

    public static void main(String[] args) {
        String str = "<div>文章標題</div><div>發佈時間</div>";
        // 貪婪模式
        Pattern pattern = Pattern.compile("<div>(?<title>.+)</div>");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group("title"));
        }

        System.out.println("--------------");

        // 非貪婪模式
        pattern = Pattern.compile("<div>(?<title>.+?)</div>");
        matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group("title"));
        }
    }
}

運行結果：

文章標題</div><div>發佈時間
--------------
文章標題
發佈時間

6. 推薦兩個在線正則工具

JavaScript、Python 等的在線表達式工具：https://regex101.com/
Java 在線表達式工具：http://www.regexplanet.com/advanced/java/index.html

7. 參考

Java Regex - Tutorial

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。