正则表达式

正则表达式（Regular Expression，简称regex或regexp）是一种强大而灵活的文本处理工具，它定义了一种字符串模式描述语言。通过正则表达式可以用来搜索、匹配、替换和提取符合特定模式的文本内容。

String提供了一个匹配正则表达式的方法

public boolean matches(String regex)	判断字符串是否匹配正则表达式，匹配则返回true，不匹配则返回false

正则表达式的书写规则

字符类(只匹配单个字符)

[abc]	只能是a，b，或c
[^abc]	除了a，b，c之外的任何字符
[a-zA-Z]	a到z A到Z，包括(范围)
[a-d[m-p]]	a 到 d，或 m 到 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])

预定义字符(只匹配单个字符)

.	任何字符
\d	一个数字：[0 - 9]
\D	非数字：[^0 - 9]
\s	一个空白字符
\S	非空白字符：[^\s]
\w	[a-zA-Z]_0-9
\W	[^\w]：一个非单词字符，匹配任何不是字母、数字或下划线的字符

数量词

X?	X，一次或零次
X*	X，零次或多次
X+	X，一次或多次
X {n}	X，正好n次
X {n, }	至少n次
X {n, m}	X，至少n但不超过m次

案例演示

public class RegularTest {
    public static void main(String[] args) {
        //字符类(只能匹配单个字符)
        //[abc]只能匹配a、b、c
        System.out.println("a".matches("[abc]"));
        //false
        System.out.println("e".matches("[abcd]"));

        System.out.println("----------------------");
        //[^abc]：除abc外的任何字符
        System.out.println("d".matches("[^abc]"));
        //false
        System.out.println("c".matches("[^abc]"));

        System.out.println("----------------------");
        //[a-h[x-z]]a到h或x到z
        System.out.println("g".matches("[a-h[x-z]]"));
        //false
        System.out.println("i".matches("[a-h[x-z]]"));

        System.out.println("----------------------");
        //[a-zA-Z]：只能是a-z  A-Z的字符
        System.out.println("b".matches("[a-zA-Z]"));
        //false
        System.out.println("5".matches("[a-zA-Z]"));

        System.out.println("----------------------");
        //[a-z&&[def]]：d，e，或f
        System.out.println("e".matches("a-z&&[def]"));
        //false
        System.out.println("a".matches("a-z&&[def]"));

        System.out.println("----------------------");
        //[a-z&&[^bc]]：a到z，除了b和c
        System.out.println("x".matches("a-z&&[^bc]"));
        //false
        System.out.println("c".matches("a-z&&[^bc]"));

        System.out.println("----------------------");
        //[a-z&&[^u-z]]：a到z，除了u到z
        System.out.println("p".matches("a-z&&[^u-z]"));
        //false
        System.out.println("v".matches("a-z&&[^u-z]]"));

        //预定义字符(只匹配单个字符)
        System.out.println("----------------------");
        //.可以匹配任意单个字符
        System.out.println("张".matches("."));
        //false
        System.out.println("小小".matches("."));

        System.out.println("----------------------");
        //  \d：0-9
        System.out.println("5".matches("\\d"));
        //false
        System.out.println("w".matches("\\d"));

        System.out.println("----------------------");
        //  \D：非数字
        System.out.println("X".matches("\\D"));
        //false
        System.out.println("2".matches("\\D"));

        System.out.println("----------------------");
        //   \s：一个空白字符
        System.out.println(" ".matches("\\s"));
        //false
        System.out.println("s".matches("\\s"));

        System.out.println("----------------------");
        //  \S：非空白字符
        System.out.println("X".matches("\\S"));
        //false
        System.out.println(" ".matches("\\S"));

        System.out.println("----------------------");
        //   \w：[a-zA-Z]_0-9，a到z A到Z 0到9
        System.out.println("9".matches("\\w"));
        //false
        System.out.println("%".matches("\\w"));

        System.out.println("----------------------");
        //   \\W：一个非单词字符,匹配任何不是字母、数字或下划线的字符
        System.out.println("*".matches("\\W"));
        //false
        System.out.println("9".matches("\\W"));

        //数量词
        System.out.println("----------------------");
        // ?代表出现1次或0次
        System.out.println("0".matches("\\d?"));
        //true
        System.out.println("".matches("\\d?"));
        //false
        System.out.println("012".matches("\\d?"));
        //"she" 不包含任何数字字符，因此它不满足这个正则表达式的匹配条件，返回结果为 false
        System.out.println("she".matches("\\d?"));

        System.out.println("----------------------");
        // *：0次或多次
        System.out.println("    ".matches("\\s*"));
        //true
        System.out.println("".matches("\\s*"));
        //s不是空白字符，不匹配
        System.out.println(" s ".matches("\\s*"));

        System.out.println("----------------------");
        //X+：一次或多次
        System.out.println("a".matches("\\w+"));
        //true
        System.out.println("a1BsaG4".matches("\\w+"));
        //false：空白字符不满足"\w"条件
        System.out.println("".matches("\\w+"));
        //false：非字母和数字及下划线不满足"\w"条件
        System.out.println(".".matches("\\w+"));

        System.out.println("----------------------");
        //X{n}：正好n次
        System.out.println("aaa".matches("a{3}"));
        //true
        System.out.println("a7bh4A".matches("\\w{6}"));
        //false
        System.out.println("a7bh4A".matches("\\w{5}"));

        System.out.println("----------------------");
        //X{n,}：至少n次
        System.out.println("aaaaaa".matches("a{2,}"));
        //false
        System.out.println("as45das".matches("\\w{8,}"));

        System.out.println("----------------------");
        //X{n,m}：至少n次，但不超过m次
        System.out.println("aaaaaa".matches("a{3,6}"));
        //false
        System.out.println("aaaaaaa".matches("a{3,6}"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

其他常用符号

(?i)	忽略大小写
\|	或
()	分组
案例演示

public class RegularTest2 {
    public static void main(String[] args) {
        //(?i)：忽略大小写
        System.out.println("abc".matches("(?i)abc"));
        //true
        System.out.println("ABC".matches("(?i)abc"));
        //false
        System.out.println("ABC".matches("a(?i)bc"));
        //true
        System.out.println("aBc".matches("a(?i)bc"));
        //false
        System.out.println("ABC".matches("a(?i)bc"));

        System.out.println("-------------------");
        // |：或
        System.out.println("abc".matches("\\d{3}|(?i)[a-z]{3}"));
        //true
        System.out.println("ABC".matches("\\d{3}|(?i)[a-z]{3}"));
        //true
        System.out.println("574".matches("\\d{3}|(?i)[a-z]{3}"));
        //false
        System.out.println("1h4".matches("\\d{3}|(?i)[a-z]{3}"));

        System.out.println("-------------------");
        //()：分组
        //需求：必须以"我爱"开头，中间至少一个"中国"，结尾至少是一个"520"
        System.out.println("我爱中国520520".matches("我爱(中国)+(520)+"));
        //false
        System.out.println("我爱中国5205205".matches("我爱(中国)+(520)+"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Pattern常用API

方法名	说明
public static Pattern compile(String regex)	将给定的正则表达式编译成模式
public Matcher matcher(CharSequence input)	创建一个匹配此模式的给定输入的匹配器
public static boolean matches(String regex)	编译给定的正则表达式并尝试将给定的输入与其匹配
public String[] split(String regex)	围绕此模式的匹配拆分给定的输入序列

Matcher常用API

方法名	说明
public boolean find()	尝试查找与模式匹配的输入序列的下一个子序列
public String group()	返回上一个匹配项匹配的输入子序列

正则表达式用于搜索替换、分割内容，需要结合String提供的如下方法完成：

方法名	说明
public static replaceAll(String regex, String newStr)	按照正则表达式匹配的内容进行替换
public String[] split(String regex)	按照正则表达式匹配的内容进行字符串分割，返回一个字符串数组

案例演示

public class RegularTest4 {
    public static void main(String[] args) {
        method1();
        // 1、public String replaceAll(String regex , String newStr)：按照正则表达式匹配的内容进行替换
        // 需求1：请把 古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴，中间的非中文字符替换成 “-”
        String str1 = "古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴";
        System.out.println(str1.replaceAll("\\w", "-"));
        // 需求2(拓展)：某语音系统，收到一个口吃的人说的“我我我喜欢编编编编编编编编编编编编程程程！”，需要优化成“我喜欢编程！”。
        /**
         * (.)一组：.匹配任意字符的。
         * \\1 :为这个组声明一个组号：1号
         * +：声明必须是重复的字
         * $1可以去取到第1组代表的那个重复的字
         */
        String str2 = "我我我喜欢编编编编编编编编编编编编程程程！";
        System.out.println(str2.replaceAll("(.)\\1+", "$1"));

        // 2、public String[] split(String regex)：按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
        // 需求1：请把 古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴，中的人名获取出来。
        System.out.println(Arrays.toString(str1.split("\\w+")));
    }

    public static void method1() {
        String data = " 来黑马程序员学习Java，\n" +
                "        电话：1866668888，18699997777\n" +
                "        或者联系邮箱：boniu@itcast.cn，\n" +
                "        座机电话：01036517895，010-98951256\n" +
                "        邮箱：bozai@itcast.cn，\n" +
                "        邮箱：dlei0009@163.com，\n" +
                "        热线电话：400-618-9090 ，400-618-4000，4006184000，4006189090";
        //定义爬取规则
        String regex = "(1[3-9]\\d{9})|(\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2})|(0\\d{2,10}-?\\d{6,10})|(400-?\\d{3,7}-?\\d{3,7})";
        //把正则表达式封装成一个Pattern对象
        Pattern pattern = Pattern.compile(regex);
        //通过Pattern对象获取查找内容的匹配器对象
        Matcher matcher = pattern.matcher(data);
        //定义循环爬取信息
        while (matcher.find()) {
            String str = matcher.group();
            System.out.println(str);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

相关阅读:
android原生集成Rn项目
 神经网络梯度是什么意思,神经网络输出层节点数
 解决IDEA actiBPM插件之.bpmn文件中文乱码
 MySQL分区、主从复制，数据库优化
 LeetCode高频题88. 合并两个有序数组
 [附源码]计算机毕业设计JAVA博客系统设计
 【微信小程序】全局配置
 offsetWidth / offsetHeight等
 java图片生成
 sqlserver常用操作总结
原文地址：https://blog.csdn.net/weixin_42195341/article/details/136272287