目录

正则表达式

基本语法

public class RegExpTest {
    public static void main(String[] args) {
        // 1. 定义一个模板(正则表达式),示例中的正则表达式:表示匹配4个相连的数字
        String regex = "(\\d\\d)(\\d\\d)";
        Pattern pattern = Pattern.compile(regex);

        // 2. 创建需要被匹配的内容
        String content = "2022年,今天风和日丽,并且天气也不错1011,你喜欢5410的风景吗?";

        // 3. 获取到一个匹配器
        Matcher matcher = pattern.matcher(content);

        // 4. 循环获取内容,在正则表达式中,每2个小括号,代表一组,示例中有2组
        while (matcher.find()) {
            String result = matcher.group(0);
            System.out.println(result);
        }
    }
}

源码解析(基于上述代码)

Matcher.find()方法

// 4.1 Matcher.find()方法,若是匹配到了内容,则返回true,否则返回false,每2个小括号,代表一组,示例中有2组
// 接下来将会分析匹配到第一个字符串时,源码中所进行的操作,之后的以此类推。
    // 4.1.1 该方法会将匹配字符串的第一个元素的索引赋值给Matcher.groups[0]
            // 例如第一次匹配到2022,其中第一个元素的索引为0,那么就赋值为0

    // 4.1.2 将匹配到的第一个字符串的最后一个元素的索引+1赋值给Matcher.groups[1]
            // 例如第一次匹配到2022,最后一个元素的索引为3,那么就赋值为4

    // 4.1.3 将匹配字符串中的”第一组分组“的第一个元素的索引赋值给Matcher.groups[2]
            // 例如匹配到的字符串为2022,第一组为20,其中第一个元素的索引为0,因此赋值0

    // 4.1.4 将匹配字符串中的”第一组分组“的最后一个元素的索引 + 1赋值给Matcher.groups[3]
            // 例如匹配到的字符串为2022,第一组为20,其中最后一个元素的索引为1,因此赋值 1 + 1 = 2

    // 4.1.5 将匹配字符串中的”第二组分组“的第一个元素的索引赋值给Matcher.groups[4]
            // 例如匹配到的字符串为2022,第二组为22,其中第一个元素的索引为2,因此赋值2

    // 4.1.6 将匹配字符串中的”第二组分组“的最后一个元素的索引赋值给Matcher.groups[5]
            // 例如匹配到的字符串为2022,第二组为22,其中最后一个元素的索引为3,因此赋值 3 + 1 = 4

Matcher.group(int group)方法

// 5. 使用Matcher.group()方法来获取匹配到的字符串数据
    // 接下来将基于第一次匹配到字符串2022时进行分析
    // 5.1 当输入group(0)时,执行到getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString()
          //5.1.1 这个getSubSequence方法相当于substring方法,用于截取传递的content的数据
          //5.1.2 因此当传入0时,groups[group * 2] 相当于 0 * 2 = groups[0] = 0,
                 //  groups[group * 2 + 1] 相当于 0 * 2 + 1 = groups[1] = 4.
                 //  而substring方法又是包含头而不包含尾的,content.substring(0, 4),就能取出2022了呗

         // 5.2.3 因此当传入1时,groups[group * 2] 相当于 1 * 2 = groups[2] = 0,
                //  groups[group * 2 + 1] 相当于 1 * 2 + 1 = groups[3] = 2.
                //  就相当于content.substring(0, 2),就能取出第一组:20,接下来的就以此类推了
    // 5.2 结论
        // group(0) 取出的是匹配的字符串
        // group(1) 取出的是第匹配到的字符串的第一组子串
        // group(2) 取出的是第匹配到的字符串的第二组子串

/*  源码如下:

    if (first < 0)
        throw new IllegalStateException("No match found");
    if (group < 0 || group > groupCount())
        throw new IndexOutOfBoundsException("No group " + group);
    if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
        return null;
    return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
 */

二个常用类

Pattern(相当于一个正则表达式)

Pattern.compile()方法

// 1. 定义一个模板(正则表达式),示例中的正则表达式:表示匹配4个相连的数字
String regex = "(\\d\\d)(\\d\\d)";
Pattern pattern = Pattern.compile(regex);

Pattern.matches()方法

public class RegExp01 {
    public static void main(String[] args) {
        // 1. 创建一个字符串
        String content = "abc abcde abcdefg";

        // 2. 定义一个正则表达式
//        String regExp = "abc";
        String regExp = "abc.*"; // 这个可以匹配整个字符串,所以Pattern.matches(regExp, content);为true

        // 3. 进行正则表达式与字符串的整体匹配,也就是看正则表达式能够匹配完一整个字符串。
        boolean matches = Pattern.matches(regExp, content);

        // 4. 执行输出结果,这里为true
        System.out.println("是否完整匹配整个字符串:" + matches);
    }
}

Matcher(匹配)

// 2. 创建需要被匹配的内容
String content = "2022年,今天风和日丽,并且天气也不错1011,你喜欢5410的风景吗?";

// 3. 获取到一个匹配器
Matcher matcher = pattern.matcher(content);

元字符

JAVA中的转义字符以及需要转义的字符

  • JAVA中的转义字符为两个反斜杠: “\”

  • 需要转义的字符如下

    1. 所有的括号,包括小括号、中括号、大括号: “() [] {}”
    2. 所有的斜杠,包括正斜杠、反斜杠:”/ “
    3. 所有的限定符,包括点、问号、加号、大括号(重复):”. ? + {}”
    4. 还有一个美元符号跟一个异或符号: “$ ^”

字符匹配符

字符匹配符 作用 正则示例 匹配结果示例
[ ] 可接收的字符列表 “[qwtg]”:表示匹配qwtg中任意的一个字符 q、w、t、g
[^ ] 不接收的字符列表 “[^qwtg]”:表示匹配除了qwtg以外的任意字符 a、e、y、d
[-] 连字符、可以写[a-z]、[A-Z]、[1-9] “[A-Z]”:表示匹配大写字母A-Z中的任意一个字符 A、B、C、D、Z
. 匹配除了\n以外的任意字符 “a..b”:匹配a开头,中间匹配2个除了\n的任意字符,b结尾 abcb、a%&b、a68b
\\d 匹配数字,等价于[1-9] “\\d”:表示匹配任意一个数字 8、9、5、1、2
\\D 匹配非数字,等价于[^1-9] “\\D”:表示匹配任意一个非数字 U、d、@、$、{
\\w 匹配字母数字下划线,等价于[a-zA-Z_] “\\w”:表示匹配一个字母或数字或下划线 a、b、e、a、6、1、_
\\W 匹配非字母数字下划线,等价于[^a-zA-Z_] “\\W”:表示匹配一个非字母或数字或下划线 !、#、@、%、(、*、/、-

[]字符匹配符的细节

  • 在[]中写的任何特殊符号,例如:.?*+=都相当于直接匹配对应的符号(可以理解为放进去就已经转义了)

选择匹配符

选择匹配符 作用 正则示例 匹配结果示例
| 表示可以匹配多个表达式、相当于或 “ab|bc|cd” : 表示可以匹配ab或者bc或者cd ab、bc、cd

限定符

限定符 作用 正则示例 匹配结果示例
? 表示匹配0个或者1个 “\\d[abc]?”:表示匹配一个数字开头、而后可以跟abc中的任意一个字母,也可以不跟 1a、3b、5c、1、5
+ 表示匹配1个或多个 “\\d[795]+”:表示匹配一个数字开头、而后至少由一个数字7、9、5任意组合的字符串 17、175、395、5957759
* 表示匹配0个或多个 “\\w[1-9]*”:表示匹配一个字母或数字、下划线开头,而后跟0个或者人一个1~9之间的字符 z12、w98、s125468
{n} 其中的n代表数量、限定匹配多少个字符 “\\d{3}”:匹配连续3个数字 159、512、202、894
{n,} 表示匹配的字符最少为n个,没有最多的限制 “\\d{2,}”:匹配最少2个数字或者更多 10、14、6661、23421、2341234、124
{n,m} 表示匹配的字符最少为n个,最多为m个 “\\d{2,4}”:匹配最少2个数字,最多4个数字 19、98、559、5598、1125、558

定位符

定位符 作用 正则示例 匹配结果示例
^ 匹配字符串的开头 “^\\d[a-z]{2}”:表示匹配一个数字开头(整个字符串),2个字母结尾 例如1ab13这个字符串能够呗匹配到,但是d1ab这个字符串匹配不到
$ 匹配字符串的结尾 “\\d[a-z]{2}$”:表示匹配一个数字开头,2个字母结尾(字符串结尾) 例如1ab这个字符串能够呗匹配到,但是2abc这个字符串匹配不到
\\b 匹配字符串的边界 “abc\\b”:表示匹配字符串边界的abc,例如一个字符串”abc adsabc asdfabcd abcsw” 可以匹配到2个abc
\\B 匹配字符串的非边界(反过来) “abc\\B”:表示匹配字符串非边界的abc,例如一个字符串”babc adsabc asdfabcd abcsw” 只能匹配到最后一个子串abcsw中的一个abc

分组组合和反向引用符(配合使用)

捕获分组、非捕获分组、反向引用

捕获分组
捕获分组构造形式 作用 正则示例 匹配结果示例
(pattern) 分组捕获 “(\\d\\d)(\\d\\d)”:匹配4个数字,分成了2组 可以group(1)和group(2)取出第一组和第二组的字符串
(?<name> pattern) 命名捕获 “(?<g1> \\d\\d)(?<g2> \\d\\d)”:匹配4个数字,分成了2组 可以group(1)和group(2)以及group(“g1”) 和 group(“g2”)取出
非捕获分组
非捕获分组构造形式 作用 正则示例 匹配结果示例
(?:pattern) 匹配但不捕获该分组,也就是调用group()方法时无法取出该分组 “快乐(?: 水|果|花)”:不会将(?: pattern)中的表达式放入group()分组中 快乐水、快乐果、快乐花
(?=pattern) 非捕获匹配 “Windows(?=2022|2021)” 可以匹配到”Windwos2022″或”Windwos2021″中的”Windows”
(?!pattern) 与上一个相反 “Windows(?=2022|2021)” 可以匹配到”Windwos2014″或”Windwos98″中的”Windows”,但就是匹配不到”Windwos2022″或”Windows2021″中的”Windwos”

反向引用(内部、外部)

  我们先来看一个需求:需要匹配一串连续的4个数字,并且保证第一位数字与第四位数字相同,第二位数字与第三位数字相同。例如:1001、8448、4554

  • 反向引用的语法:

    1. 在正则表达式内部使用时候只需要 “\group“,这里的group表示引用第几组

    2. 在正则表达式外部时使用”$group“,例如matcher.replaceAll()方法4

    3. 第几组是根据正则表达式中的捕获分组来决定的,第一个括号是第一组,以此类推

    4. 具体的使用将会在应用实例中演示

应用实例

实现不区分大小写

如下正则表达式:

  • “abc” :表示匹配abc,区分大小写
  • “(?i)abc”: 表示匹配abc,不区分大小写
  • “ab(?i)c”: 表示匹配时,c不区分大小写
  • “a((?i)b)c”:表示匹配时,b不区分大小写

贪婪匹配、非贪婪匹配(懒惰匹配)

  • 如果想要实现非贪婪匹配,需要在限定符后添加一个”?”也就是问号。

  • 例如有一个字符串”aaa”,正则表达式为:”a+”,此时默认为贪婪匹配,因此只有一个结果:”aaa”

  • 例如有一个字符串”aaa”,正则表达式为:”a+?”,此时为非贪婪匹配,因此可以匹配到3个结果:”a”、”a”、”a”

常用元字符练习

获取汉字

public class RegExp02 {
    public static void main(String[] args) {
        String content = "今天  你 没想到 吧";

        // 正则表达式
        String regExp = "[\\u4e00-\\u9fa5]+";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        // 记录找到了多少组
        int count = 0;

        while (matcher.find()) {
            System.out.println("找到了,这是第" + ++count + "组:" + matcher.group(0));
        }
    }
}

获取邮政编码:要求是1-9开头的六位数

public class RegExp02 {
    public static void main(String[] args) {
        String content = "15812 595125 951236 015487 6514 25654 00154";

        // 正则表达式
        String regExp = "[1-9]\\d{5}";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        // 记录找到了多少组
        int count = 0;

        while (matcher.find()) {
            System.out.println("找到了,这是第" + ++count + "组:" + matcher.group(0));
        }
    }
}

QQ号码:要求1-9开头的一个(5位数-10位数)

public class RegExp02 {
    public static void main(String[] args) {
        String content = "2571986664aaf257198666dsf25719#$!02121/*-abcadsf";

        // 正则表达式
        String regExp = "[1-9]\\d{4,9}";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        // 记录找到了多少组
        int count = 0;

        while (matcher.find()) {
            System.out.println("找到了,这是第" + ++count + "组:" + matcher.group(0));
        }
    }
}

手机号码:以13、14、15、18开头的11位数

public class RegExp02 {
    public static void main(String[] args) {
        String content = "15277303777a2134a1427730377734098asdf1527730377adf";

        // 正则表达式
        String regExp = "1[3|4|5|8]\\d{9}";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        // 记录找到了多少组
        int count = 0;

        while (matcher.find()) {
            System.out.println("找到了,这是第" + ++count + "组:" + matcher.group(0));
        }
    }
}

URL:匹配一个URL网址,可以带端口及不带端口

public class RegExp02 {
    public static void main(String[] args) {
//        String content = "https://vip.iqiyi.com/cps_pc.html?a=b&b=c";
        String content = "https://vip.iqiyi.com:3918/cps_pc.html?a=b&b=c";

        // 正则表达式
        String regExp = "^(http|https)://([\\w+.]+)(:\\d+)?/[\\w.]+\\??[\\S]*$";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到了:" + matcher.group(0));
        }
    }
}

按照如下电子邮件规则编写正则表达式

  1. 只能有一个@
  2. @前面是用户名,可以是a-z A-Z 0-9 _ – 等字符
  3. @后面是域名,域名只能是英文字母,比如sohu.com或baidu.org.cn
public class RegExp02 {
    public static void main(String[] args) {
        String content = "codeStars@163.com.cn";

        // 正则表达式
        String regExp = "^[\\w-]+@[a-zA-Z0-9.]*[a-zA-Z0-9]+$";

        if (content.matches(regExp)) {
            System.out.println("匹配成功");
        }else {
            System.out.println("匹配失败");
        }
    }
}

要求匹配到整数或者小数,要求考虑正数及负数

public class RegExp02 {
    public static void main(String[] args) {
        // 需要限制00.45、-00.45之类的错误输入格式
        // 123 -345 34.89 -87.9 -0.01 0.45 -00.45
        String content = "-0.01";

        // 正则表达式
        String regExp = "^[+-]?([\\d+|0?])\\.?\\d+$";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到:" + matcher.group(0));
        }
    }
}

对一个url进行解析

  1. 获取到协议: http或https
  2. 域名是什么?
  3. 端口是什么?
  4. 文件名是什么?
public class RegExp02 {
    public static void main(String[] args) {
        String content = "https://mail.163.com:8080/register/success.htm";

        // 正则表达式思路
        // 1. 先获取到协议(http|https),以及增加固定的分隔符 ://
        // 2. 获取域名([\\w.]+)
        // 3. 获取端口([:\\d]+)
        // 4. 过滤不需要捕获的内容(?:[\\w]+/)+
        // 5. 获取文件名 ([\\w.]+)
        String regExp = "(http|https)://([\\w.]+)([:\\d]+)(?:[\\w]+/)+([\\w.]+)";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("协议为:" + matcher.group(1));
            System.out.println("域名为:" + matcher.group(2));
            System.out.println("端口为:" + matcher.group(3));
            System.out.println("资源名称为:" + matcher.group(4));
        }
    }
}

非捕获分组练习

获取Windows10和Windows11中的Windows,不包括Windows12、Windows2018中的Windows

public class RegExp02 {
    public static void main(String[] args) {
        String content = "Windows2211 Windows10 Windows11 Windows12 Windows2018";

        // 正则表达式  获取Windows10和Windows11中的Windows,不包括Windows12、Windows2018中的Windows
        String regExp = "Windows(?=10|11)";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到:" + matcher.group(0));
            System.out.println("索引开始位置为:" + matcher.start());
            System.out.println("索引结束位置为:" + (matcher.end() - 1));
        }
    }
}

获取不包括Windows10和Windows11中的Windows,其他的都要,例如Windows12、Windows2018中的Windows

public class RegExp02 {
    public static void main(String[] args) {
        String content = "Windows2211 Windows10 Windows11 Windows12 Windows2018";

        // 正则表达式  获取不包括Windows10和Windows11中的Windows,其他的都要,例如Windows12、Windows2018中的Windows
        String regExp = "Windows(?!10|11)";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到:" + matcher.group(0));
            System.out.println("索引开始位置为:" + matcher.start());
            System.out.println("索引结束位置为:" + (matcher.end() - 1));
        }
    }
}

反向引用练习(注意与捕获分组使用)

实现匹配1221、2332、4554之类的数字

public class RegExp02 {
    public static void main(String[] args) {
        String content = "4554 2662 1234 8448 9119 1331 5897 2222";

        // 正则表达式
        String regExp = "(\\d)(\\d)\\2\\1";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到:" + matcher.group(0));
        }
    }
}

要求满足前面是一个五位数,加一个-号,后续是一个九位数,每3位要相同

例如:13541-555222111、59511-666333444

public class RegExp02 {
    public static void main(String[] args) {
        String content = "13541-555222111、59511-666333444、12465-123456789";

        // 正则表达式
        String regExp = "\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}";

        Pattern pattern = Pattern.compile(regExp);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到:" + matcher.group(0));
        }
    }
}

解决结巴语句,例如:今今…,,天也是…个好..好好好….日日子转换为 今天是个好日子

public class RegExp02 {
    public static void main(String[] args) {
        String content = "今今...,,天也是...个好..好好好....日日子";

        // 正则表达式
        // 思路
        // 1. 先将所有其他的特殊符号去除掉,由于该字符串中只有. 和 , 所以只放了2个
        String regExp = "[.,\\s]+";

        Pattern pattern = Pattern.compile(regExp);
        Matcher matcher = pattern.matcher(content);

        // 1.1 将找到的特殊符号都替换成空字符串,该行执行后content就变成了:今今天也是个好好好好日日子
        content = matcher.replaceAll("");
        // 编写正则表达式,匹配一个非空字符而后必须有1个或多个与其一样的字符
        regExp = "(\\S)\\1+";

        // 2. 重新创建Pattern和Matcher
        pattern = Pattern.compile(regExp);
        matcher = pattern.matcher(content);

        // 3. 使用replaceAll方法来替换掉,需要使用到外部引用$
        //  上面编写的正则表达式会找到3个字符串,分别为:今今、好好好好、日日
        // 底层会循环的调用find()方法,相当于找到一个字符串,就用其第一组的内容替换整个字符串,以此类推就能全部替换
        String newContent = matcher.replaceAll("$1");
        System.out.println(newContent); // 输出结果:今天也是个好日子
    }
}