Java正则表达式入门学习与实践

最新推荐文章于 2024-08-19 20:59:41 发布

和烨

最新推荐文章于 2024-08-19 20:59:41 发布

阅读量335

点赞数

分类专栏：工具文章标签：正则表达式 java 后端

本文链接：https://blog.csdn.net/weixin_46146718/article/details/121090765

版权

工具专栏收录该内容

37 篇文章 5 订阅

订阅专栏

Java正则表达式入门学习与实践

一、正则基础知识点
二、正则进阶知识点
三、贪婪和非贪婪
- 1、贪婪
- 2、懒惰（非贪婪）
四、反义
五、案例
- 1、匹配时间

一、正则基础知识点

1、元字符

元字符	说明
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

元字符案例
匹配有abc开头的字符串

\babc或者^abc

匹配8位数字的QQ号码

^\d\d\d\d\d\d\d\d$

匹配1开头11位数字的手机号码

^1\d\d\d\d\d\d\d\d\d\d$

2、重复限定符

语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

重复限定符案例
匹配8位数字的QQ号码

在这里插入代码片

匹配1开头11位数字的手机号码

^1\d{10}$

匹配银行卡号是14~18位的数字

^\d{14,18}$

匹配以a开头的，0个或多个b结尾的字符串

^ab*$

3、分组

匹配字符串中包含0到多个ab开头

^(ab)*

4、转义

如果要匹配的字符串中本身就包含小括号，那是不是冲突？应该怎么办？

针对这种情况，正则提供了转义的方式，也就是要把这些元字符、限定符或者关键字转义成普通的字符，做法很简答，就是在要转义的字符前面加个斜杠，也就是\即可。
如：要匹配以(ab)开头

^(\(ab\))*

5、条件或

正则用符号 | 来表示或，也叫做分支条件，当满足正则里的分支条件的任何一种条件时，都会当成是匹配成功。

^(130|131|132|155|156|185|186|145|176)\d{8}$

6、区间

正则提供一个元字符中括号 [] 来表示区间条件。

限定0到9 可以写成[0-9]
限定A-Z 写成[A-Z]
限定某些数字 [165]

那上面的正则我们还改成这样

^((13[0-2])|(15[56])|(18[5-6])|145|176)\d{8}$

二、正则进阶知识点

1、零宽断言

语法	说明
(expr)	捕获 expr 子模式,以 \1 使用它。
(?:expr)	忽略捕获的子模式。
(?=expr)	正向预查模式 expr。
(?!expr)	负向预查模式 expr。

(?=pattern)
正向肯定预查（look ahead positive assert），匹配pattern前面的位置。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。

简单说，以 xxx(?=pattern)为例，就是捕获以pattern结尾的内容xxx

例如，“Windows(?=95|98|NT|2000)“能匹配"Windows2000"中的"Windows”，但不能匹配"Windows3.1"中的"Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

(?!pattern)
正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。

简单说，以 xxx(?!pattern)为例，就是捕获不以pattern结尾的内容xxx

例如"Windows(?!95|98|NT|2000)“能匹配"Windows3.1"中的"Windows”，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

(?<=pattern)
反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。

简单说，以(?<=pattern)xxx为例，就是捕获以pattern开头的内容xxx。

例如，"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。

(?<！pattern)
简单说，以(?<!pattern)xxx为例，就是捕获不以pattern开头的内容xxx。

反向否定预查，与正向否定预查类似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。

2、零宽断言测试

class DemoApplicationTests {

    void contextLoads() {
        //创建测试样例
        String test = "abc123xyz";
        //创建正则表达式
        String reg1 = "\\w(?=123)";
        String reg2 = "\\w(?!123)";
        String reg3 = "(?<=abc)\\w";
        String reg4 = "(?<!abc)23";
        Pattern pattern1 = Pattern.compile(reg1);
        Pattern pattern2 = Pattern.compile(reg2);
        Pattern pattern3 = Pattern.compile(reg3);
        Pattern pattern4 = Pattern.compile(reg4);
        //查找
        Matcher mc1 = pattern1.matcher(test);
        Matcher mc2 = pattern2.matcher(test);
        Matcher mc3 = pattern3.matcher(test);
        Matcher mc4 = pattern4.matcher(test);
        if (mc1.find()) {
            System.out.println(mc1.group());
        }
        if (mc2.find()) {
            System.out.println(mc2.group());
        }
        if (mc3.find()) {
            System.out.println(mc3.group());
        }
        if (mc4.find()) {
            System.out.println(mc4.group());
        }
    }
}

在这里插入图片描述

3、捕获和非捕获

数字编号捕获组
语法：(exp)解释：从表达式左侧开始，每出现一个左括号和它对应的右括号之间的内容为一个分组，在分组中，第0组为整个表达式，第一组开始为分组。
比如固定电话的：020-85653333
他的正则表达式为：(0\d{2})-(\d{8})
按照左括号的顺序，这个表达式有如下分组：

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	1	(0\d{2])	020
2	2	(\d{8})	85653333

class DemoApplicationTests {

    @Test
    void contextLoads1() {
        String test = "020-85653333";
        String reg = "(0\\d{2})-(\\d{8})";
        Pattern pattern = Pattern.compile(reg);
        Matcher mc = pattern.matcher(test);
        if (mc.find()) {
            System.out.println("分组的个数有：" + mc.groupCount());
            for (int i = 0; i <= mc.groupCount(); i++) {
                System.out.println("第" + i + "个分组为：" + mc.group(i));
            }
        }
    }
 }

在这里插入图片描述
可见，分组个数是2，但是因为第0个为整个表达式本身，因此也一起输出了。

命名编号捕获组
语法：(?exp)
解释：分组的命名由表达式中的name指定
比如区号也可以这样写:(?\0\d{2})-(?\d{8})
按照左括号的顺序，这个表达式有如下分组：

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	quhao	(0\d{2])	020
2	haoma	(\d{8})	85653333

class DemoApplicationTests {

    @Test
    void contextLoads1() {
        String test = "020-85653333";
        String reg = "(?<quhao>0\\d{2})-(?<haoma>\\d{8})";
        Pattern pattern = Pattern.compile(reg);
        Matcher mc = pattern.matcher(test);
        if (mc.find()) {
            System.out.println("分组的个数有：" + mc.groupCount());
            System.out.println(mc.group("quhao"));
            System.out.println(mc.group("haoma"));
        }
    }
}

在这里插入图片描述

非捕获组
语法：(?:exp)
(?:expr) 忽略捕获的子模式。
解释：和捕获组刚好相反，它用来标识那些不需要捕获的分组，说的通俗一点，就是你可以根据需要去保存你的分组。

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	quhao	(0\d{2])	020

比如上面的正则表达式，程序不需要用到第一个分组，那就可以这样写：

class DemoApplicationTests {

    @Test
    void contextLoads1() {
        String test = "020-85653333";
        String reg = "(?:0\\d{2})-(\\d{8})";
        Pattern pattern = Pattern.compile(reg);
        Matcher mc = pattern.matcher(test);
        if (mc.find()) {
            System.out.println("分组的个数有：" + mc.groupCount());
            for (int i = 0; i <= mc.groupCount(); i++) {
                System.out.println("第" + i + "个分组为：" + mc.group(i));
            }
        }
    }
}

在这里插入图片描述

3、反向引用

根据捕获组的命名规则，反向引用可分为

数字编号组反向引用：\k或\number
命名编号组反向引用：\k或者’name’

反向引用如:\1,\2等
\1：表示的是引用第一次匹配到的()括起来的部分
\2：表示的是引用第二次匹配到的()括起来的部分

例：(\d)\1
首先这里是匹配两位，\d一位,\1又引用\d一位这里的\1会去引用（\d）匹配到的内容，因为(\d)是第一次匹配到的内容。
如：str = "22"时，(\d)匹配到2，所以\1引用(\d)的值也为2，所以str="22"能匹配
str = "23"时，(\d)匹配到2，因为\1引用(\d)的值2,而这里是3，所以str="23"不能匹配

例：(\d)\10-9\2{2}
这里使用了\2引用第二次匹配到的分组，这里第二次匹配的分组为\2前面的(\d)，这里的{2}指的是\2的值出现两次
如：第一个(\d)为4时，\1引用第1个(\d)也为4，第二个(\d)为5时，\2引用第二个(\d)为5，所以结果可以是:447555,440222

在这里插入图片描述
例：(\d)\1[0-9](\d)\1{2}
注意在后面第二个(\d)\1{2}中的\1，这里的\1并不会去匹配他前面的(\d)，而是匹配第一个(\d),
如：第一个(\d)为3时，则第一个\1也为3，同样最后那个\1也为3，所以结果可以是335933,332533而不是336444,339888
在这里插入图片描述

例：((\d)3)\1[0-9](\d)\2{2}
当匹配中的分组有嵌套时，是从外向里匹配的，其次在由左向右匹配
这里主要是分析匹配到分组的顺序，首先匹配((\d)3)这整个部分，其次匹配((\d)3)里面的(\d)，第三次匹配时最后一个\2前面的(\d)
如：如((\d)3)中的(\d)为2时，((\d)3)的值为23，此时\1为((\d)3)的值1，而\2引用((\d)3)中的(\d)的值3，第三个(\d)为5时，此时\3引用第三个(\d)的值5,所以结果可以有：23238522，23230522，

在这里插入图片描述

三、贪婪和非贪婪

1、贪婪

贪婪匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符，这匹配方式叫做贪婪匹配。特性：一次性读入整个字符串进行匹配，每当不匹配就舍弃最右边一个字符，继续匹配，依次匹配和舍弃（这种匹配-舍弃的方式也叫做回溯），直到匹配成功或者把整个字符串舍弃完为止，因此它是一种最大化的数据返回，能多不会少。

用来匹配3到6位数字，在这种情况下，它是一种贪婪模式的匹配，也就是假如字符串里有6个个数字可以匹配，那它就是全部匹配到。
如

class DemoApplicationTests {

    void contextLoads3() {
        String reg = "\\d{3,6}";
        String test = "61762828 176 2991 871";
        System.out.println("文本：" + test);
        System.out.println("贪婪模式：" + reg);
        Pattern p1 = Pattern.compile(reg);
        Matcher m1 = p1.matcher(test);
        while (m1.find()) {
            System.out.println("匹配结果：" + m1.group(0));
        }
    }
}

在这里插入图片描述

是这样的，多个贪婪在一起时，如果字符串能满足他们各自最大程度的匹配时，就互不干扰，但如果不能满足时，会根据深度优先原则，也就是从左到右的每一个贪婪量词，优先最大数量的满足，剩余再分配下一个量词匹配。

class DemoApplicationTests {

    @Test
    void contextLoads3() {
        String reg = "(\\d{1,2})(\\d{3,4})";
        String test = "61762828 176 2991 87321";
        System.out.println("文本：" + test);
        System.out.println("贪婪模式：" + reg);
        Pattern p1 = Pattern.compile(reg);
        Matcher m1 = p1.matcher(test);
        while (m1.find()) {
            System.out.println("匹配结果：" + m1.group(0));
        }
    }
}

在这里插入图片描述

“617628” 是前面的\d{1,2}匹配出了61，后面的匹配出了7628
“2991” 是前面的\d{1,2}匹配出了29 ，后面的匹配出了91
"87321"是前面的\d{1,2}匹配出了87，后面的匹配出了321

2、懒惰（非贪婪）

懒惰匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能少的字符，这匹配方式叫做懒惰匹配。特性：从左到右，从字符串的最左边开始匹配，每次试图不读入字符匹配，匹配成功，则完成匹配，否则读入一个字符再匹配，依此循环（读入字符、匹配）直到匹配成功或者把字符串的字符匹配完为止。

代码	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

class DemoApplicationTests {

    void contextLoads3() {
        String reg = "(\\d{1,2}?)(\\d{3,4})";
        String test = "61762828 176 2991 87321";
        System.out.println("文本：" + test);
        System.out.println("贪婪模式：" + reg);
        Pattern p1 = Pattern.compile(reg);
        Matcher m1 = p1.matcher(test);
        while (m1.find()) {
            System.out.println("匹配结果：" + m1.group(0));
        }
    }
}

在这里插入图片描述

解答
“61762” 是左边的懒惰匹配出6，右边的贪婪匹配出1762
“2991” 是左边的懒惰匹配出2，右边的贪婪匹配出991
“87321” 左边的懒惰匹配出8，右边的贪婪匹配出7321

四、反义

前面说到元字符的都是要匹配什么什么，当然如果你想反着来，不想匹配某些字符，正则也提供了一些常用的反义元字符：

元字符	解释
\w	匹配任意不是字母，数字，下划线，汉字的字符
\s	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意亨符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

五、案例

1、匹配时间

\d{4}年?/?\d{1,2}月?/?\d{1,2}日?([ ]\d{1,2}:?时?\d{1,2}:?分?\d{1,2}秒?)?

在这里插入图片描述

和烨

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java正则表达式入门学习与实践

Java正则表达式入门学习与实践
复制链接

扫一扫

专栏目录

Java正则表达式入门学习与实践

Java正则表达式入门学习与实践

一、正则基础知识点

1、元字符

2、重复限定符

3、分组

4、转义

5、条件或

6、区间

二、正则进阶知识点

1、零宽断言

2、零宽断言测试

3、捕获和非捕获

3、反向引用

三、贪婪和非贪婪

1、贪婪

2、懒惰（非贪婪）

四、反义

五、 案例

1、匹配时间

五、案例