学习笔记--Java正则表达式常用知识点总结

最新推荐文章于 2025-03-27 16:30:45 发布

小小卷王

最新推荐文章于 2025-03-27 16:30:45 发布

阅读量211

点赞数

分类专栏：笔记

本文链接：https://blog.youkuaiyun.com/m0_46219348/article/details/109675416

版权

笔记专栏收录该内容

61 篇文章

订阅专栏

Java 正则表达式

一个正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称作正则表达式中的元字符。正则表达式定义了字符串的模式，可以用来搜索、编辑或处理文本，并不仅限于某一种语言，但是在每种语言中有细微的差别。

1. 正则表达式语法

在 Java 中，\ \ 有着特殊的意义，这个表示要插入一个正则表达式的反斜线，\ 后面有的字符具有特殊的意义。一个 \ 有着转义的作用。

字符	在正则表达式中的写法	说明
.	.	匹配除了 “\r\n”之外的任何一个字符
\d	\ \d	代表 0 到 9 的任何一个数字，等效于 [0-9]
\D	\ \D	代表任何一个非数字字符，等效于 [ ^ 0-9]
\s	\ \s	匹配任何空白字符，包括空格，‘\t’，‘\n’，‘\x0B’，‘\f’，‘\r’，\s+可以匹配多个空格
\S	\ \S	代表非空格类字符
\w	\ \w	代表可用于标识符的字符(不包括美元符号)
\W	\ \W	代表不能用于标识符的字符
\p{Lower}	\ \p{Lower}	小写字母[a~z]
\p{Upper}	\ \p{Upper}	大写字母[A~Z]
\p{ASCII}	\ \p{ASCII}	ASCII字符
\p{Alpha}	\ \p{Alpha}	字母
\p{Digit}	\ \p{Digit}	数字字符，即[0~9]
\p{Alnum}	\ \p{Alnum}	字母或数字
\p{Punct}	\ \p{Punct}	标点符号：！“ # $ % & ‘ ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { \| } ~
\p{Graph}	\ \p{Graph}	可视字符：\p{Alnum}\p{Punct}
\p{Print}	\ \p{Print}	可打印字符：\p{Graph}
\p{Blank}	\ \p{Blank}	空格或制表符 [\t]
\p{Cntrl}	\ \p{Cntrl}	控制字符： [\x00-\x1F\x7F]

字符	说明
\	转义字符，将下一个字符标记为特殊字符，文本，反向引用或八进制转义符。\n 匹配换行符，\ \ ( 匹配（
^	匹配输入字符串开始的位置
$	匹配输入字符串结尾的位置
*	零次或多次匹配前面的字符或子表达式。例如：ab* 匹配 “ab”，”abb”，等效于 {0，}
+	一次或多次匹配前面的字符或子表达式。例如：ab+ 匹配 “ab” ，“abb”但不匹配“a”，等效于{1，}
？	零次或一次匹配匹配钱前面的字符或子表达式。例如：ab 匹配 “ab”，“a”，等效于{0,1}
{n}	n 是非负正数，正好匹配 n 次。例如：a{2} 匹配 ”aa“
{n，}	n 是非负整数。至少匹配 n 次。例如：a{2，} 匹配 ”aaaaaa“，a{1，} 等效于”a+“，a{n，}等效于 ”o*“
{n，m}	m和n都是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如：a{1，3} 匹配 ”baa“ ，”o{0，1}“等效于 ”o？“，注意：不能将空格插入逗号和数字之间。
？	当次字符紧随任何其他限定符(*,+,?,{n},{n,},{n,m})之后时，匹配模式是“非贪心的”。“非贪心的”模式匹配搜索到的，尽可能短的字符串，而默认的“贪心的”模式匹配搜索到的，尽可能长的字符串。例如：在“aaaa”中，“a+?”只匹配单个 a，o+匹配所有的 a
(pattern)	匹配 pattern 并捕获该匹配的子表达式。例如：要匹配（，java使用 (“\ \ (”)
(?:pattern)	匹配pattern但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。例如：（?:a\|b）cc 匹配 acc，bcc
(?=pattern)	执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如：'Windows (?=95\|98\|2000）`匹配 Windows 2000 中的 Window，但不匹配 Windows 3 中的 Windows。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern)	执行反向预测先行搜索的子表达式该表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如：'Windows (?!95\|98\|2000)` 匹配 Windows 3 中的 Windows，但不匹配 Windows 2000 中的 Windows。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
x\|y	匹配 x 或 y。例如：a\|b 匹配 a 或 b
[xyz]	字符集。匹配包含的任一字符。例如： [abc] 匹配 book 中的 b
[^xyz]	反向字符集。匹配未包含的任何字符。例如：[ ^ abc] 匹配 book 中的 o k
[a-z]	字符范围。匹配指定范围内的任何字符。例如：[a-z] 匹配 a 到 z 内的任何小写字母
[^a-z]	反向字符范围。匹配不在指定的范围内的任何字符。例如：[ ^a-z] 匹配任何不在 a 到 z 范围内的任何字符
\b	匹配一个字边界，即字与空格间的位置。例如：“er\b” 匹配 never 中的 er ，但不匹配 verb 中 er
\B	非字边界匹配。“er\B” 匹配 verb 中的 er，但不匹配 never 中的 er
\cx	匹配 x 指示的控制字符。例如：\cM 匹配 Control-M 或回车符。x 的值必须在 A -Z 或 a - z 之间。如果不是这样，则假定 c 就是 “c” 字符本身。
\f	换页符匹配。等效于 \x0c 和 \cL
\n	换行符匹配。等效于 \x0a 和 \cJ
\r	匹配一个回车符。等效于 \x0d 和 \cM
\t	制表符匹配。等效于 \x09 和 \cl
\v	垂直制表符匹配。等效于 \x0b 和 \cK
\w	匹配任何字类字符，包括下划线。等效于 [A-Za-z0-9_]
\W	匹配任何非单词字符，等效于[ ^ fA-Za-z0-9_]
\xn	匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如：\x041 匹配 A。\x041 与 \x04 & 1 等效，允许在正则表达式中使用 ASCII 代码
\num	匹配 num，此处的 num 是一个正整数，到捕获匹配的反向引用。例如：“(.)\1” 匹配两个连续的相同字符
\n	标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数(0-7)，那么 n 是八进制转义码
\nm	标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)
\nml	当 n 是八进制数(0-3)，m 和 / 是八进制数 (0-7) 时，匹配八进制转义码 nml
\un	匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如：\u00A9 匹配版权符号 @

2. 捕获组

捕获组就是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

捕获组是通过从从左至右计算其开括号来编号。例如：在表达式（（A）（B（C））），有四个组：

（（A）（B（C）））
（A）
（B（C））

（C）

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示 matcher 对象当前有多少个捕获组，特殊组(group(0))，它总是代表整个表达式，不包括在groupCount的返回值中。

public class TestString {
    public static void main(String[] args) {
        Pattern regex = Pattern.compile("((A)(B(C)))");

        Matcher matcher = regex.matcher("ABC");
        System.out.println(matcher.groupCount());
        matcher.find();
        System.out.println(matcher.group(0));
        System.out.println(matcher.group(1));
        System.out.println(matcher.group(2));
        System.out.println(matcher.group(3));
        System.out.println(matcher.group(4));
    }
}

运行结果：
    4
    ABC
    ABC
    A
    BC
    C

3. Pattern 类

Pattern 类用于创建一个正则表达式，也可以说创建一个匹配模式。它的构造方法是私有的，不可以直接创建，但可以通过 Pattern.complie(String regex) 简单工厂方法创建一个正则表达式。

public class TestString {
    public static void main(String[] args) {
        Pattern regex = Pattern.compile("\\d+");
        System.out.println(regex.pattern());
    }
}

运行结果：
    \d+
返回的是 regex 的参数

3.1 Pattern.split(CharSequence input)

功能：用于分隔字符串，并返回一个 String[]

public class TestString {
    public static void main(String[] args) {
        Pattern regex = Pattern.compile("\\d+");
        String[] str = regex.split("a1b2c3d4");
        for (String s : str) {
            System.out.println(s);
        }
    }
}

运行结果：
    a
    b
    c
    d

3.2 Pattern.matches(String regex, CharSequence input)

功能：静态方法，用于快速匹配字符串，该方法适合用于只匹配一次，且匹配全部字符串

public class TestString {
    public static void main(String[] args) {
        System.out.println(Pattern.matches("\\d+", "33"));
        System.out.println(Pattern.matches("\\d+", "33aa"));
    }
}

运行结果：
    true
    false

3.3 Pattern.matcher(CharSequence input)

返回一个 Matcher 对象，Matcher 类的构造方法也是私有的，不能随意创建，只能通过 Pattern.matcher(CharSequence input)方法得到该类似的实例。

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("123");
        System.out.println(matcher.pattern());
    }
}

运行结果：
    \d+
返回的 pattern，也就是返回 Mathcer 对象是由那个 Pattern 对象创建的

Pattern 类只能做一些简单的匹配操作，要想得到更好的正则匹配操作需要将 Pattern 和 Matcher 一起合作。Matcher 类提供了对正则表达式的分组支持，以及对正则表达式的多次匹配操作。

4. Matcher 类

4.1 Matcher.matches()

功能：匹配操作方法，返回 boolean 类型，当匹配到时返回true，否则返回 false。

matches 是对整个字符串进行匹配，只有整个字符串都匹配了才返回 true

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("123");
        System.out.println(matcher.matches());
        Matcher matcher1 = pattern.matcher("123abc");
        System.out.println(matcher1.matches());
    }
}

运行结果：
    true
    false

4.2 Matcher.lookingAt()

功能：匹配操作方法，返回 boolean 类型，对前面的字符串进行匹配，只有匹配的字符串在最前面才返回true，

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("123");
        System.out.println(matcher.lookingAt());
        Matcher matcher1 = pattern.matcher("123abc");
        System.out.println(matcher1.lookingAt());
        Matcher matcher2 = pattern.matcher("abc123");
        System.out.println(matcher2.lookingAt());
    }
}

运行结果：
    true
    true
    false

4.3 Matcher.find()

功能：匹配操作方法，返回 boolean 类型，匹配到的字符串可以在任何位置

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("a123b");
        System.out.println(matcher.find());
        Matcher matcher1 = pattern.matcher("123abc");
        System.out.println(matcher1.find());
        Matcher matcher2 = pattern.matcher("abc123");
        System.out.println(matcher2.find());
    }
}

运行结果：
    true
    true
    true

4.4 Matcher.start()

功能：返回匹配到的字符串在字符串中的索引位置

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");

        Matcher matcher = pattern.matcher("123");
        System.out.println(matcher.matches());
        System.out.println(matcher.start());

        Matcher matcher1 = pattern.matcher("123abc");
        System.out.println(matcher1.lookingAt());
        System.out.println(matcher1.start());

        Matcher matcher2 = pattern.matcher("abc123");
        System.out.println(matcher2.find());
        System.out.println(matcher2.start());
    }
}
运行结果：
    true 
    0
    true
    0
    true
    3

4.5 Matcher.end()

功能：返回匹配到的字符串的最后一个字符在字符串中的索引位置

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");

        Matcher matcher = pattern.matcher("123");
        System.out.println(matcher.matches());
        System.out.println(matcher.end());

        Matcher matcher1 = pattern.matcher("123abc");
        System.out.println(matcher1.lookingAt());
        System.out.println(matcher1.end());

        Matcher matcher2 = pattern.matcher("abc123");
        System.out.println(matcher2.find());
        System.out.println(matcher2.end());
    }
}

运行结果：
    true
    3
    true
    3
    true
    6

4.6 Matcher.group()

功能：返回匹配到的子字符串

public class TestString {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");

        Matcher matcher = pattern.matcher("123");
        System.out.println(matcher.matches());
        System.out.println(matcher.group());

        Matcher matcher1 = pattern.matcher("123abc");
        System.out.println(matcher1.lookingAt());
        System.out.println(matcher1.group());

        Matcher matcher2 = pattern.matcher("abc123");
        System.out.println(matcher2.find());
        System.out.println(matcher2.group());
    }
}

运行结果：
    true
    123
    true
    123
    true
    123

4.7 replaceFirst和replaceAll方法

功能：替换匹配正则表达式的文本，replaceFirst替换首次匹配，replaceAll替换所有匹配

public class TestString {
    public static void main(String[] args) {
        String str = "I am a student, he is a student";
        String regex = "student";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        System.out.println(matcher.replaceFirst("teacher"));
        System.out.println(matcher.replaceAll("teacher"));
    }
}

运行结果：
    I am a teacher,he is a student
    I am a teacher,he is a teacher