Java 正则表达式


#Java 笔记

正则表达式， regular expression，可以用来搜索和处理文本。

语法

正则表达式中有一些字符代表着特定的含义，比如+表示匹配前面的字符/表达式0到多次。这种特定含义的字符，可以看做是正则表达式语言中的保留关键词，有些资料中也称作为元字符。有些元字符之间需要成对出现，例如 { 和 }。元字符之前也可以搭配使用。有些元字符，在不同的使用场景中含义不同。

语法 说明
^ 匹配开始位置
$ 匹配结束位置
\ 转义
* 匹配前面的字符/表达式 0 次或多次
+ 匹配前面的字符/表达式 1 次或多次
? 匹配前面的字符/表达式 0 次或1次。在 *、+、?、{m}、{m,}、{m,n} 之后出现时，代表匹配模式是非贪心的。
. 默认模式下, 匹配\r、\n外的所有单个字符。
{m} 匹配前面的字符/表达式 m 次。 m >=0 。默认是贪心匹配。
{m, n} 匹配前面的字符/表达式 m 次到 n 次。 m >=0, n >= m。默认是贪心匹配。
{m,} 匹配前面的字符/表达式至少 m 次。 m >=0。默认是贪心匹配。
a|b 匹配 a 或者 b
a|xyz 匹配 a 或者 xyz
[xyz] 匹配 x 或者 y 或者 z
[^xyz] 匹配不是 x、y、z 的字符
[a-z] 匹配 a 到 z 之间的字符，包含 a、z。
[^a-z] 匹配不是 a 到 z 之间的字符，a、z 也不匹配。
[0-9] 匹配 0 到 9 之间的字符，包含 0、9。
(pattern) 匹配 pattern 对应的正则表达式，并生成捕获组
(?:pattern) 匹配 pattern 对应的正则表达式，不生成捕获组
(?<groupName>pattern) 匹配 pattern 对应的正则表达式，并生成捕获组，组名是groupName。
\1 反向引用前面的编号为1的捕获组。不会生成捕获组。类似的，还有\2、\3等。
\b 匹配单词边界。在英文中，单词之间用空格隔开。单词边界是指单词和空格之间的部分。这是一个抽象的概念，因为单词和空格之间的部分是看不到的。
\B 匹配非单词边界。
\d 匹配数字字符。即[0-9]
\D 匹配非数字字符。即[^0-9]
\n 匹配换行符
\r 匹配回车符
\f 匹配换页符
\t 匹配制表符
\v 匹配垂直制表符
\s 配置空白符号。即[\n\r\f\t\v]
\S 匹配非空白符号
\w 匹配字母、数字、下划线。即[A-Za-z0-9_]
\W 不匹配字母、数字、下划线。即[^A-Za-z0-9_]
\x23 匹配 ascii 表中十六进制的 23 对应的字符。\x后必须是2个16进制字符。
\u1234 匹配 16 进制的 1234 对应的 unicode 字符。\u后必须是4个16进制字符。这是 UTF-16 的字符编码。表情符号以及一些生僻字，会需要两个\u才行。例如\ud83d\ude0a 对应 😊。
其他字符 匹配对应的字符

贪心匹配 是尽可能多的匹配，非贪心匹配是尽可能少的匹配。

转义规则

在正则表达式中?代表匹配前面的字符/表达式0次或者1次。如果要匹配字符?，那么正则表达式处理引擎应该看到的是\?。我们在 Java 中书写的字符串形式的正则表达式应该是 \\?。

要匹配字符\，Java 中要写成\\\\。

注意，在其他一些编程语言中，匹配字符?，只需要\?即可， \\? 反而是错误的。

使用 String 的 matches 方法判断字符串是否匹配正则表达式

matches 返回 boolen 值。

示例: 判断字符串中是否有英文句号.

public class RegexTest {

    public static void main(String[] args) {
        String regex = "(\\s|\\S)*\\.(\\s|\\S)*";
        System.out.println( "".matches(regex) );             // false
        System.out.println( "你好".matches(regex) );          // false
        System.out.println( "你好.".matches(regex) );         // true
        System.out.println( "你好 .".matches(regex) );        // true
        System.out.println( "你好 . 世界".matches(regex) );    // true
        System.out.println( "你好\n .".matches(regex) );      // true
    }
}

\s 用于匹配空白字符，\S 匹配非空白字符。\.用于匹配英文逗号.

示例: 判断字符串不为空，且只含有数字

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[0-9]+";
        System.out.println( "".matches(regex) );           // false
        System.out.println( "你好".matches(regex) );        // false
        System.out.println( "0".matches(regex) );          // true
        System.out.println( "012".matches(regex) );        // true
        System.out.println( "129".matches(regex) );        // true
        System.out.println( "129.".matches(regex) );       // false
    }
    
}

示例: 判断字符串是整数或小数, 小数点后最多8位

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[0-9]+\\.?[0-9]{0,8}";
        System.out.println( "".matches(regex) );                // false
        System.out.println( "你好".matches(regex) );            // false
        System.out.println( "0".matches(regex) );               // true
        System.out.println( "012".matches(regex) );             // true
        System.out.println( "129".matches(regex) );             // true
        System.out.println( "129.".matches(regex) );            // true
        System.out.println( "0129.".matches(regex) );           // true
        System.out.println( "129.000".matches(regex) );         // true
        System.out.println( "129.000111".matches(regex) );      // true
        System.out.println( "129.000111222".matches(regex) );   // false
        System.out.println( "129x00222".matches(regex) );       // false
    }

}

012 也返回 true，在一些场景下，是不符合预期的。

示例: 判断字符串含有小数点，且小数点前后都是数字，且小数点前若有多个数字，最高位不能是0

public class RegexTest {

    public static void main(String[] args) {
        String regex = "(([1-9]+[0-9]*)|0)\\.[0-9]+";
        System.out.println( "".matches(regex) );                // false
        System.out.println( "你好".matches(regex) );            // false
        System.out.println( "0".matches(regex) );               // false
        System.out.println( "012".matches(regex) );             // false
        System.out.println( "129".matches(regex) );             // false
        System.out.println( "129.".matches(regex) );            // false
        System.out.println( "0129.".matches(regex) );           // false
        System.out.println( "129.000".matches(regex) );         // true
        System.out.println( "129.000111".matches(regex) );      // true
        System.out.println( "129.000111222".matches(regex) );   // true
        System.out.println( "129x00222".matches(regex) );       // false
    }

}

示例: 判断字符串为空，或者仅由字母abc中的一个或多个组成

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]*";
        System.out.println( "".matches(regex) );         // true
        System.out.println( "a".matches(regex) );        // true
        System.out.println( "ab".matches(regex) );       // true
        System.out.println( "abc".matches(regex) );      // true
        System.out.println( "abccba".matches(regex) );   // true
        System.out.println( "abc-cba".matches(regex) );  // false
        System.out.println( "ABC".matches(regex) );      // false
    }

}

使用 Pattern.matches 方法判断字符串是否匹配正则表达式

String 的 matches 方法，底层调用的 Pattern.matches 方法。

Pattern.matches 方法源码：

public static boolean matches(String regex, CharSequence input) {
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(input);
    return m.matches();
}

使用示例:

import java.util.regex.Pattern;

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]*";
        System.out.println( Pattern.matches(regex, "a") );    // true
        System.out.println( Pattern.matches(regex, "123") );  // false
    }

}

使用 Pattern.compile 编译正则表达式

示例:

import java.util.regex.Pattern;

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]*";
        Pattern pattern = Pattern.compile(regex);

        System.out.println( pattern.matcher("a").matches() );    // true
        System.out.println( pattern.matcher("123").matches() );  // false
    }

}

使用 Matcher 找到匹配正则表达式的字符串

示例: 使用 find(), start(), end()

find() 返回是否找到匹配正则表达式的字符串。start()、end() 返回所匹配的字符串的位置。

第一次执行 find() 时，会从字符串初始位置开始查找。在找到了匹配的字符串后，会变更下次查找的初始位置。

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]+";
        String data = "a123bc";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.printf(
                    "start: %d, end: %s, string: %s\n",
                    matcher.start(),
                    matcher.end(),
                    data.substring(matcher.start(), matcher.end())
            );
        }
    }

}

执行结果:

start: 0, end: 1, string: a
start: 4, end: 6, string: bc

理解【捕获组】

在正则表达式中，可以应该能括号对匹配的内容进行分组。我们可以利用这个机制来提取我们需要的内容。

例如，正则表达式 ((a)(b(c)))，会匹配 abc 这样的连续字符。组编号和内容如下：

组编号 内容
1 ((a)(b(c)))
2 (a)
3 (b(c))
4 (c)

示例: 获取捕获组的数量和每个组的内容

代码示例1:

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "((a)(b(c)))";
        String data = "abc-ab";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);
        while (matcher.find()) {
            System.out.println("groupCount: " + matcher.groupCount());  // 获取分组数量
            System.out.println("group(0): " + matcher.group(0));        // 0 不代表捕获组, 代表匹配的字符串
            System.out.println("group(1): " + matcher.group(1));
            System.out.println("group(2): " + matcher.group(2));
            System.out.println("group(3): " + matcher.group(3));
            System.out.println("group(4): " + matcher.group(4));
        }

    }

}

执行结果:

groupCount: 4
group(0): abc
group(1): abc
group(2): a
group(3): bc
group(4): c

注意, group(0) 是匹配的字符串，不算在捕获组中。

代码示例2:

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "((a)(b(c)))[a-z]*";
        String data = "abc-abcd";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);
        while (matcher.find()) {
            System.out.println("-------");
            System.out.println("groupCount: " + matcher.groupCount());
            System.out.printf("start: %d, end: %s\n", matcher.start(), matcher.end());
            System.out.println("group(0): " + matcher.group(0));
            System.out.println("group(1): " + matcher.group(1));
            System.out.println("group(2): " + matcher.group(2));
            System.out.println("group(3): " + matcher.group(3));
            System.out.println("group(4): " + matcher.group(4));
        }

    }

}

执行结果:

groupCount: 4
start: 0, end: 3
group(0): abc
group(1): abc
group(2): a
group(3): bc
group(4): c
-------
groupCount: 4
start: 4, end: 8
group(0): abcd
group(1): abc
group(2): a
group(3): bc
group(4): c

代码示例3:

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "<h2>(.*)</h2>";
        String data = "你好<h2>世界</h2>";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);
        while (matcher.find()) {
            System.out.println(matcher.group(1));
        }
    }

}

执行结果:

世界

代码示例4:

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]+";
        String data = "a123bc";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);
        System.out.println( matcher.groupCount() ); 
    }

}

执行结果:

0

示例: 命名捕获组

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "(?<num>[0-9]+)";
        String data = "123-789";
        Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.println( matcher.group() );
            System.out.println( matcher.group("num") );
            System.out.println("----");
        }
    }

}

运行结果:

123
123
----
789
789
----

示例: 反向引用

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "([a-z]*)-\\1";
        String data = "abc-abcd@mail.com";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);
        while (matcher.find()) {
            System.out.println("-------");
            System.out.println("groupCount: " + matcher.groupCount());
            System.out.println("group(0): " + matcher.group(0));
            System.out.println("group(1): " + matcher.group(1));
        }

    }

}

执行结果:

-------
groupCount: 1
group(0): abc-abc
group(1): abc

String 的 replaceFirst、replaceAll 的特殊用法：调整捕获组位置

replaceFirst、replaceAll 的第一个参数是正则表达式，第二个参数是要替换的内容。但是第2个参数比较特殊, 在这里面$1代表第1个捕获组的内容，$2代表第2个捕获组的内容，依次类推。

如果要替换为字符串$1，要写成\\$1。

代码示例:

public class RegexTest {

    public static void main(String[] args) {
        String regex = "([abc]+)-([a-z]+)";
        System.out.println( "ab-ccc".replaceFirst(regex, "$2-$1"));
        System.out.println( "ab-ccc".replaceFirst(regex, "\\$2-$1"));
    }

}

执行结果:

ccc-ab
$2-ab

贪心匹配与非贪心匹配

贪心匹配 是尽可能多的匹配，非贪心匹配是尽可能少的匹配。

*、+、?、{m}、{m,}、{m,n} 默认是贪心匹配。当?出现在他们后面时，代表非贪心匹配。

示例：贪心匹配

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]+";
        String data = "a123bc";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.printf(
                    "start: %d, end: %s, string: %s\n",
                    matcher.start(),
                    matcher.end(),
                    data.substring(matcher.start(), matcher.end())
            );
        }
    }

}

执行结果:

start: 0, end: 1, string: a
start: 4, end: 6, string: bc

示例: 非贪心匹配

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]+?";
        String data = "a123bc";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.printf(
                    "start: %d, end: %s, string: %s\n",
                    matcher.start(),
                    matcher.end(),
                    data.substring(matcher.start(), matcher.end())
            );
        }
    }

}

执行结果:

start: 0, end: 1, string: a
start: 4, end: 5, string: b
start: 5, end: 6, string: c

使用 String 的 replaceAll 替换掉符合正则表达式的字符串

replaceAll 会替换掉所有符合正则表达式的子字符串。

代码示例:

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]+";
        System.out.println( "ab123abc".replaceAll(regex, "替换后"));
    }

}

执行结果:

替换后123替换后

使用 String 的 replaceFirst 替换掉符合正则表达式的字符串

replaceFirst 会替换掉第一个符合正则表达式的子字符串。

代码示例:

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[abc]+";
        System.out.println( "ab123abc".replaceFirst(regex, "替换后"));
    }

}

执行结果:

替换后123abc

使用 Pattern.DOTALL 让英文句号.支持匹配\r、\n

默认是不匹配换行符的。

代码示例:

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = ".*";
        String data = "aaaa\nbbbbb";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        if (matcher.find()) {
            System.out.println( matcher.group() );
        }
    }

}

执行结果:

aaaa

Pattern.compile 设置模式为 Pattern.DOTALL 时，则支持匹配\r、\n 。

代码示例:

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = ".*";
        String data = "aaaa\nbbbbb";
        Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
        Matcher matcher = pattern.matcher(data);

        if (matcher.find()) {
            System.out.println( matcher.group() );
        }
    }

}

执行结果:

aaaa
bbbbb

使用 ^、$ 匹配开始位置和结束位置

示例: 使用 ^ 匹配开始位置

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "^[0-9]+";
        String data = "123abc456";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.println( matcher.group() );
        }
    }

}

执行结果:

123

只匹配到了 123, 没有匹配到 456。

###示例: 使用 $ 匹配结束位置

代码示例1

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[0-9]+$";
        String data = "123abc456";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.println( matcher.group() );
        }
    }

}

执行结果:

456

代码示例2

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[0-9]+$";
        String data = "123abc456\n789";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.println( matcher.group() );
        }
    }

}

执行结果:

789

为什么没有匹配到 456 ？因为默认情况下结束位置是指整个文本的结束位置，而不是每一行的结束位置。

若要匹配到456，可以指定Pattern.MULTILINE来实现。见下面的示例。

示例: 使用Pattern.MULTILINE 让 $匹配每一行的结束位置

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

public class RegexTest {

    public static void main(String[] args) {
        String regex = "[0-9]+$";
        String data = "123abc456\n789";
        Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE);
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.println( matcher.group() );
        }
    }

}

执行结果:

456
789


( 本文完 )