18.正则表达式

Pupper2023-02-202024-10-30

一、正则表达式

1. 常用类

Pattern 类 :

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

Matcher 类:

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

2.使用方法

使用步骤:

创建正则表达式的匹配模式
1. Pattern.compile("\\(");
根据匹配模式创建匹配器, 匹配字符串
1. pattern.matcher(content);
使用 while 循环进行匹配
1. matcher.find() : 找到返回 true, 找到返回 false;
2. matcher.group(0): 将匹配的结果输出; 1. 没有分组时, 使用 group(0) 输出匹配结果; 1. 有分组时, 0 为本次匹配的结果, 1 为匹配结果的第一个分组, 2 为第二个分组, 以此类推;

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

// 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 中, 两个 \ 代表其他语言中的一个 \

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 个字母组成的字符串

// ? 和 其他限定符号一起使用时, 为非贪婪模式

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\\b	han 后接空格或者字符串结束位置的 han
\\B	匹配目标字符串的非边界	han\\B	han 后没有空格或不是字符串结束位置的 han

字符串边界: 指字符串中的空格或者结尾;

三、分组

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

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

常用分组构造形式	说明	备注
(?:pattern)	非分组匹配	- 匹配 pattren, 但不捕获该匹配的子表达式; - 即它是一个非捕获匹配, 不存储供以后使用的匹配; - 对于 or 字符 (\|) 组合模式部件的情况很有用 - 如 `industr(?:y\|ies)` - 等价于 `industry\|industries`
(?=pattern)	非分组匹配	- 如: `Windows (?=95\|98\|NT\|2000)` - 匹配 “Windows 2000” 中的 windows - 但不匹配 “Windows 3.1” 中得 windows
(?!pattern)	非分组匹配	- 如: `Windows (?!95\|98\|NT\|2000)` - 匹配 “Windows 3.1” 中的 windows, - 但不匹配 “Windows 2000” 中得 windows

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 表示第一个分组的内容, 以此类推;
反向引用 : 圆括号匹配的内容, 在该括号后被使用的模式;
反向引用即可以在表达式内部, 也可以在表达式外部:
- 表达式内部: \分组号
- 表达式外部: $分组号

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);
    }
}

五、案例

// 使用正则表达式, 直接操作字符串 - 案例

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]);
        }
    }
}

// 正则 - 案例

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 数字：^[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})?$
7 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$
8 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
9 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
10 有1~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-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号：
		15或18位身份证：^\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和1～12)：^(0?[1-9]|1[0-2])$
14 一个月的31天(01～09和1～31)：^((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.1到3个数字,后面跟着任意个 逗号+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地址时有用)