18.正则表达式

一、正则表达式

1. 常用类

Pattern 类 :

  • pattern 对象是一个正则表达式对象, 没有公共构造方法, 通过调用器公共方法, 返回 pattern 类;
    • 该方法接收一个正则表达式作为他的第一个参数
    • Pattern pattern = Pattern.compile(regStr);

Matcher 类:

  • Matcher 对象是对输入的字符串进行匹配, 没有公共的构造方法,
    • 需要调用 Pattern 对象的 matcher 方法获取一个 Matcher 对象;
    • Matcher matcher = pattern.matcher(content);
      PatternSyntaxException : 表示正则表达式的语法错误;

2.使用方法

使用步骤:

  1. 创建 正则表达式的匹配模式
    1. Pattern.compile("\\(");
  2. 根据 匹配模式创建匹配器, 匹配字符串
    1. pattern.matcher(content);
  3. 使用 while 循环进行匹配
    1. matcher.find() : 找到 返回 true, 找到返回 false;
    2. matcher.group(0): 将匹配的结果输出; 1. 没有分组时, 使用 group(0) 输出匹配结果; 1. 有分组时, 0 为本次匹配的结果, 1 为匹配结果的第一个分组, 2 为第二个分组, 以此类推;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class RegexpDemo1 {
public static void main(String[] args) {
String content = "asdas$(sldkjasljf($saldfjla";
// 1. 创建 正则表达式的匹配模式
String regStr = "\\(";
Pattern pattern = Pattern.compile(regStr);
// 2. 根据 匹配模式创建匹配器, 匹配字符串
Matcher matcher = pattern.matcher(content);
// 3. matcher.find() : 找到 返回 true, 找到返回 false
while (matcher.find()){
// matcher.group(0) : 没有分组时, 使用 0 取出匹配结果
// matcher.group(1) : 有分组时, 0 为本次匹配的结果, 1 为匹配结果的第一个分组, 2 为第二个分组, 以此类推
System.out.println(matcher.group(0));
}
}
}

3. matchers 整体匹配

matchers() : 可用于 字符串 和 匹配规则的整体匹配, 匹配成功, 返回 true, 否则, 返回 false

1
2
3
4
5
6
7
8
9
10
11
12
// Pattern.matchers 整体匹配

public class RegexpDemo2 {
public static void main(String[] args) {
String str = "https://www.bilibili.com/video/BV1fh411y7R8?p=894&spm_id_from=pageDriver&vd_source=af07764917c38a3d6871e700a168f287";
String regStr = "(https?)://([\\w-]+\\.)+([\\w-]+)(/[\\w-]+)+\\?([\\w-]+=[\\w-]+&?)+";

// 整体匹配
boolean matches = Pattern.matches(regStr, str);
System.out.println(matches);
}
}

二、元字符

1. 转义号 - \

转义号 \ : 在使用正则表达式去检索某些特殊字符时, 需要用到转义号, 否则会检索不到结果或报错; *在 java 中, 两个 \ 代表其他语言中的 一个 \

1
2
3
4
5
6
7
8
9
10
11
public class RegexpDemo1 {
public static void main(String[] args) {
String content = "asdas$(sldkjasljf($saldfjla";
String regStr = "\\(";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
System.out.println(matcher.group(0));
}
}
}

2. 字符匹配符

符号说明实例解释
[ ]可匹配的字符列表[efgh]e、f、g、h 中的任意一个字符
不可的匹配字符列表abc除了 a、b、c 之外的任意一个字符
-连字符A-Z任意一个大写字母
.匹配除了 \n 以外的任意字符a..b以 a 开头, 以 b 结尾, 长度为 4 个字符的字符串
\\d匹配单个数字字符, 等价于[0-9]\\d{3}(\\d)?包含 3 或 4 个数字的字符串
\\D匹配单个非数字字符, 等价于0-9\\D(\\d)*以非数字开头, 后面接任意个数字的字符串
\\w匹配单个数字、大小写字母、下划线字符, 等价于[0-9a-zA-Z_]\\d{3}\\w{4}以 3 个数字开头, 后面接非特殊字符, 长度为 7 的字符串
\\W匹配单个非数字、大小写字母、下划线字符, 等价于0-9a-zA-Z_\\W+\\d{2}以至少一个特殊字符开头, 2 个数字结尾的字符串
\\s匹配单个空格、制表符\\s+\\s匹配字符串前后空格
\\S匹配单个 非空格、制表符, 等价于\\\\s\\S匹配除空格外的任意单个字符
  • [a-z] : 表示可以匹配 a-z 中任意一个字符;
  • java 中 正则表达式默认区分大小写, 可以使用 **(?i)** 表示不区分大小写:
    • Pattern.compile("\\(", Pattern.CASE_INSENSITIVE)
      • Pattern.CASE_INSENSITIVE: 表示该匹配规则 不区分大小写;
    • (?i)abc : 表示 abc 不区分大小写;
    • a(?i)bc : 表示 bc 不区分大小写;
    • a((?i)b)c : 表示 b 不区分大小写;

3. 选择匹配符

符号说明实例解释
|匹配 “|” 之前或之后的字符串ab|cd匹配 ab 或 cd

4. 限定符

  • java 中, 正则匹配默认为 贪婪匹配(尽可能多的匹配)_** , 会尽可能匹配多的内容;
  • 当 ? 和 其他限定符号一起使用时, 则为 **非贪婪匹配(尽可能少的匹配) ;
符号说明实例解释
_指定字符重复任意次数(abc)_仅包含 任意个 abc 的字符串, 等价于\\w*
+指定字符重复至少一次m+(abc)*以至少 1 个 m 开头, 后接任意个 abc 的字符串
?指定字符重复 0 次或 1 次m+abc?以至少 1 个 m 开头, 后接 ab 或 abc 的字符串
{n}只能匹配 n 个字符[abcd]{3}由 abcd 中任意 3 个字母组成的字符串
{n,}指定至少 n 个字符[abcd]{3,}由 abcd 中任意至少 3 个字母组成的字符串
{n,m}指定至少 n 个,至多 m 个字符[abcd]{3, 5}由 abcd 中任意至少 3 个至多 5 个字母组成的字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// ? 和 其他限定符号一起使用时, 为非贪婪模式

public class RegexpDemo2 {
public static void main(String[] args) {
String str1 = "hello111111 ok";

// String str2 = "\\d+"; // 贪婪匹配 111111
String str2 = "\\d+?"; // 非贪婪匹配 1 1 1 1 1 1

Pattern compile = Pattern.compile(str2);
Matcher matcher = compile.matcher(str1);
while (matcher.find()){
// 匹配到的字符串
System.out.println("找到了: " + matcher.group(0));
}
}
}

5. 定位符

符号说明实例解释
^指定其实位置^[0-9]+[a-z]*以至少 1 个数字开头, 后接任意个小写字母
$指定结束位置^[0-9]\\\\-[a-z]+$以 1 个数字开头, 接-, 接 至少 1 个字母结尾
\\b匹配目标字符串的边界han\\bhan 后接空格或者字符串结束位置的 han
\\B匹配目标字符串的非边界han\\Bhan 后没有空格或不是字符串结束位置的 han
  • 字符串边界: 指字符串中的空格 或者 结尾;

三、分组

常用分组构造形式说明备注
(pattern)非命名分组0 : 表示由整个正则表达式匹配的文本
n : 表示其他正则规则匹配的结果, 从 1 开始编号
(?<name>pattern)命名分组- 将匹配的子字符串用一个名称或编号命名;
- 用于 命名的 字符串不能有任何标点符号, 不能以数字开头
- 可以使用 ‘’ 单引号 代替 尖括号 <>

非分组匹配, 不能使用 matcher.group(1)

常用分组构造形式说明备注
(?:pattern)非分组匹配- 匹配 pattren, 但不捕获该匹配的子表达式;
  - 即它是一个非捕获匹配, 不存储供以后使用的匹配;
- 对于 or 字符 (|) 组合模式部件的情况很有用
  - 如 industr(?:y&#124;ies)
  - 等价于 industry&#124;industries
(?=pattern)非分组匹配- 如: Windows (?=95&#124;98&#124;NT&#124;2000)
  - 匹配 “Windows 2000” 中的 windows
  - 但不匹配 “Windows 3.1” 中得 windows
(?!pattern)非分组匹配- 如: Windows (?!95&#124;98&#124;NT&#124;2000)
  - 匹配 “Windows 3.1” 中的 windows,
  - 但不匹配 “Windows 2000” 中得 windows
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
public class RegexpDemo2 {
public static void main(String[] args) {
String str1 = "wobuvidctameng a7789,nn1189vidc";

// 匿名分组
// String str2 = "(\\d\\d)(\\d\\d)";

// 命名分组
String str2 = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
Pattern compile = Pattern.compile(str2);
Matcher matcher = compile.matcher(str1);
while (matcher.find()){
// 匹配到的字符串
System.out.println("找到了: " + matcher.group(0)); // 7789 1189

// 匹配到的字符串的第一个分组(命名分组即可以通过编号, 也可以通过命名获取)
System.out.println("找到了: " + matcher.group(1)); // 77 11
System.out.println("找到了: " + matcher.group("g1")); // 77 11

// 匹配到的字符串的第二个分组
System.out.println("找到了: " + matcher.group(2)); // 89 89
System.out.println("找到了: " + matcher.group("g2")); // 89 89
}

}
}

四、反向引用

  • 分组: 用圆括号组成一个比较复杂的匹配模式, 圆括号的部分就可以看做为一个分组或一个子表达式;
  • 捕获: 将匹配到的内容存放在内存中, 0 表示整个表达式匹配的内容, 1 表示第一个分组的内容, 以此类推;
  • 反向引用 : 圆括号匹配的内容, 在该括号后被使用的模式;
  • 反向引用即可以在表达式内部, 也可以在表达式外部:
    • 表达式内部: \分组号
    • 表达式外部: $分组号
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
public class RegexpDemo2 {
public static void main(String[] args) {
String content = "我...我要...学学学学...Java 编程!";

Pattern compile = Pattern.compile("(\\.)+");
Matcher matcher = compile.matcher(content);

// 找到所有的 "." , 用空字符替换
content = matcher.replaceAll("");
System.out.println(content);
//
// // 找到重复的字
// compile = Pattern.compile("(.)\\1+");
// matcher = compile.matcher(content);
//
// while (matcher.find()){
// System.out.println("找到了: " + matcher.group(0));
// }
//
// // 替换重复的字
// content = matcher.replaceAll("$1");

// 简写
content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
System.out.println(content);
}
}

五、案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 使用正则表达式, 直接操作字符串 - 案例

public class RegexpDemo3 {
public static void main(String[] args) {
String str = "2000年5月,JDK1.3、JDK1.4和J2SE1.3相继发布";

// 将 JDK1.3 和 JDK1.4 替换为 JDK
str = str.replaceAll("JDK1\\.3|JDK1\\.4", "JDK");
System.out.println(str);

// 判断字符串以 135 或 136 开头
String content = "13598987878";
boolean matches = content.matches("1(35|36)\\d{8}");
System.out.println(matches);

// 按 #, -, ~, 数字 分割字符串
String s1 = "hello#abc-jack12smith~北京";
String[] split = s1.split("#|-|~|\\d+");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
}
}
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
// 正则 - 案例

public class RegexpDemo2 {
public static void main(String[] args) {
// 匹配汉字
// String str = "这里都是汉字";
// String regStr = "^[\u0391-\uffe5]+$";

// 匹配邮编
// String str = "321123";
// String regStr = "^[1-9]\\d{5}$";

// 匹配 QQ 号码
// String str = "410977619";
// String regStr = "^[1-9]\\d{4,9}$";

// 手机号码
// String str = "15366668888";
// String regStr = "^1[3|4|5|8]\\d{9}$";

// ur;
String str = "https://www.bilibili.com/video/BV1fh411y7R8?p=894&spm_id_from=pageDriver&vd_source=af07764917c38a3d6871e700a168f287";
String regStr = "^(https?)://([\\w-]+\\.)+([\\w-]+)(/[\\w-]+)+\\?([\\w-]+=[\\w-]+&?)+$";


Pattern compile = Pattern.compile(regStr);
Matcher matcher = compile.matcher(str);
if (matcher.find()){
System.out.println("匹配到了: " + matcher.group(0));
}else {
System.out.println("没有匹配到");
}
}
}

六、常用正则表达式

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
一、校验数字的表达式

1 数字:^[0-9]*$
2 n位的数字:^\d{n}$
3 至少n位的数字:^\d{n,}$
4 m-n位的数字:^\d{m,n}$
5 零和非零开头的数字:^(0|[1-9][0-9]*)$
6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)+(.[0-9]{1,2})?$
71-2位小数的正数或负数:^(\-)?\d+(\.\d{1,2})?$
8 正数、负数、和小数:^(\-|\+)?\d+(\.\d+)?$
9 有两位小数的正实数:^[0-9]+(.[0-9]{2})?$
101~3位小数的正实数:^[0-9]+(.[0-9]{1,3})?$
11 非零的正整数:^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
12 非零的负整数:^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
13 非负整数:^\d+$ 或 ^[1-9]\d*|0$
14 非正整数:^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
15 非负浮点数:^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16 非正浮点数:^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17 正浮点数:^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18 负浮点数:^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19 浮点数:^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$


二、校验字符的表达式

1 汉字:^[\u4e00-\u9fa5]{0,}$
2 英文和数字:^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
3 长度为3-20的所有字符:^.{3,20}$
4 由26个英文字母组成的字符串:^[A-Za-z]+$
5 由26个大写英文字母组成的字符串:^[A-Z]+$
6 由26个小写英文字母组成的字符串:^[a-z]+$
7 由数字和26个英文字母组成的字符串:^[A-Za-z0-9]+$
8 由数字、26个英文字母或者下划线组成的字符串:^\w+$ 或 ^\w{3,20}$
9 中文、英文、数字包括下划线:^[\u4E00-\u9FA5A-Za-z0-9_]+$
10 中文、英文、数字但不包括下划线等符号:^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11 可以输入含有^%&',;=?$\"等字符:[^%&',;=?$\x22]+
12 禁止输入含有~的字符:[^~\x22]+


三、特殊需求表达式

1 Email地址:^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2 域名:[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3 InternetURL:[a-zA-z]+://[^\s]* 或 ^https://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4 手机号码:^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX):^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6 国内电话号码(0511-4405222021-87888822):\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号:
1518位身份证:^\d{15}|\d{18}$
15位身份证:^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$
18位身份证:^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$
8 短身份证号码(数字、字母x结尾):^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9 帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10 密码(以字母开头,长度在6~18之间,只能包含字母、数字和下划线):^[a-zA-Z]\w{5,17}$
11 强密码(必须包含大小写字母和数字的组合,不能使用特殊字符,长度在8-10之间):^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12 日期格式:^\d{4}-\d{1,2}-\d{1,2}
13 一年的12个月(01~09和112):^(0?[1-9]|1[0-2])$
14 一个月的31天(01~09和131):^((0?[1-9])|((1|2)[0-9])|30|31)$
15 钱的输入格式:
16 1.有四种钱的表示形式我们可以接受:"10000.00""10,000.00", 和没有 "分""10000""10,000":^[1-9][0-9]*$
17 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式:^(0|[1-9][0-9]*)$
18 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号:^(0|-?[1-9][0-9]*)$
19 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分:^[0-9]+(.[0-9]+)?$
20 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10""10.2" 是通过的:^[0-9]+(.[0-9]{2})?$
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样:^[0-9]+(.[0-9]{1,2})?$
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样:^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
23 8.13个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须:^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
24 备注:这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
25 xml文件:^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26 中文字符的正则表达式:[\u4e00-\u9fa5]
27 双字节字符:[^\x00-\xff] (包括汉字在内,可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1))
28 空白行的正则表达式:\n\s*\r (可以用来删除空白行)
29 HTML标记的正则表达式:<(\S*?)[^>]*>.*?|<.*? /> (网上流传的版本太糟糕,上面这个也仅仅能部分,对于复杂的嵌套标记依旧无能为力)
30 首尾空白字符的正则表达式:^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等),非常有用的表达式)
31 腾讯QQ号:[1-9][0-9]{4,} (腾讯QQ号从10000开始)
32 中国邮政编码:[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
33 IP地址:\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)