正则表达式

一、为什么要学习正则表达式

几个问题

1. 给你一个字符串（或文章），请你找出所有四个数字连在一起的子串
2. 给你一个字符串（或文章），请你找出所有四个数字连在一起的子串，并且这四个数字要满足：第一位与第四位相同，第二位与第三位相同，比如1221，5775
3. 请验证输入的邮件，是符合电子邮件的格式
4. 请验证输入的手机号，是否符合手机号格式

解决

• Java提供了正则表达式技术，专门用于处理类似文本问题

二、正则表达式底层实现

实例分析

• 问题

  • 给你一个字符串（或文章），请你找出所有四个数字连在一起的子串

• 代码

package regexp;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegTheory {
    public static void main(String[] args) {
        //复制一段文本
        String content = "按照惯例，在履行完相关流程后，奚国华将出任董事长，" +
                "成为这家中央直接领导的巨型国企一把手。走过44年历史的中信，" +
                "也即将迎来继荣毅仁（任期1979-1993）、魏鸣一（1993-1995）、" +
                "王军（1995-2006）、孔丹（2006-2010）、常振明（2010-2020）、" +
                "朱鹤新（2020-2023）之后的第七任董事长。";
        //目标：匹配所有的四个数字
        //1. \\d 表示一个任意的数字
        String regStr = "(\\d\\d)(\\d\\d)";
        //2. 创建模式对象[即正则表达式]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        //说明：创建匹配器matcher，按照正则表达式的规则去匹配
        Matcher matcher = pattern.matcher(content);
        // 开始匹配
        while (matcher.find()){
            System.out.println("找到:"+matcher.group(0));
            System.out.println("找到:"+matcher.group(1));
            System.out.println("找到:"+matcher.group(2));
        }
        /*
        原理：
        matcher.find() 完成的任务（考虑分组）
        什么是分组，比如(\d\d)(\d\d)，正则表达式中有()表示分组，第1个()表示第1组，第2个()表示第2组
        1.根据指定的规则，定位满足规则的子字符串(比如(19)(79))
        2.找到后，将 子字符串的开始的索引记录到 matcher对象的属性 int[] groups
        3.同时记录oldLat的值为子字符串的结束的索引+1的值，下次执行的时候从这个索引开始匹配
        追源码理解。。
         */
    }
}

三、正则表达式语法

元字符的功能

1. 限定符
2. 选择匹配符
3. 分组组合和反向引用符
4. 特殊字符
5. 字符匹配符
6. 定位符

3.1 转义号 \\

• 在我们使用正则表达式去检索某些特殊字符的时候，需要用到转义符号，否则检索不到结果。
• 在Java正则表达式中，两个\\代表其他语言中的一个\

        String content = "abc$(a.bc(123()";
        //匹配左括号
//        String regStr = "\\(";
        //匹配符号点
//        String regStr = "\\.";
        //匹配数字
//        String regStr = "\\d\\d\\d";
        String regStr = "\\d{3}";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到 "+matcher.group(0));
        }

3.2 元字符-字符匹配符

        String content = "a11c8abc_ABCy @";
//        String regStr = "[a-z]";//匹配a-z之间任意一个字符
//        String regStr = "[A-Z]"; //匹配 A-Z之间的任意一个字符
//        String regStr = "abc"; //匹配 abc 字符串[默认区分大小写]
//        String regStr = "(?i)abc"; //匹配abc字符串[不区分大小写]
//        String regStr = "[0-9]"; //匹配 0-9 之间任意一个字符
//        String regStr = "[^a-z]"; //匹配不在a-z之间任意一个字符
//        String regStr = "[^0-9]"; //匹配 不在0-9之间任意一个字符
//        String regStr = "[abcd]"; //匹配在abcd中任意一个字符
//        String regStr = "\\D"; //匹配 不在 0-9的任意一个字符
//        String regStr = "\\w"; //匹配大小写英文字母，数字，下划线
//        String regStr = "\\W"; //匹配 等价于 [^a-zA-Z0-9_]
//        String regStr = "\\s"; //匹配任何空白字符(空格，制表符)
//        String regStr = "\\S"; //匹配任何非空白字符，和\\s刚好相反
        String regStr = "."; //匹配出\n之外的所有字符，如果是匹配. 本身则需要使用\\.
        //指定Pattern.CASE_INSENSITIVE表示匹配不区分字母大小写
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到："+matcher.group(0));
        }

3.3 元字符-选择匹配符

        String content = "hanshunping 韩 寒冷";
        String regStr = "han|韩|寒";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到："+matcher.group(0));
        }

3.4 元字符-限定符

        String content = "a211111aaaaaahello";
//        String regStr = "a{3}"; //表示匹配 aaa
//        String regStr = "1{4}"; //表示匹配 1111
//        String regStr = "\\d{2}"; //表示匹配 两位的任意数字字符

        //细节：java匹配默认贪婪匹配
//        String regStr = "a{3,4}"; //表示匹配 aaa或者aaaa
//        String regStr = "1{4,5}"; //表示匹配 1111 或 11111
//        String regStr = "\\d{2,5}"; //表示匹配 2 3 4 5 位数

        //1+
//        String regStr = "1+"; //匹配一个1或者多个1
//        String regStr = "\\d+"; //匹配一个数字或者多个数字
        //1*
//        String regStr = "1*"; //匹配0个1或多个1

        //演示?的使用，遵守贪婪匹配
        String regStr = "a1?"; //匹配a或 a1
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到："+matcher.group(0));
        }

3.5 元字符-定位符

• 定位符，规定要匹配的字符串出现的位置，比如在字符串的开始还是在结束的位置。

        String content = "hanshunping sphan nnhan";
//        String content = "123-abc";
//        String regStr ="^[0-9]+[a-z]*"; //以至少1个数字开头，后接任意个小写字母的字符串
//        String regStr = "^[0-9]+\\-[a-z]+$"; //以至少1个数字开头，必须以至少一个小写字母结束
//        String regStr = "han\\b"; //匹配边界的han【这里的边界指的是被匹配字符串的最后和空格的子串的最后】
        String regStr = "han\\B"; //和\\b恰好相反
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到："+matcher.group(0));
        }

3.6 分组

        String content = "hanshunping s7789 nn1189han";
        //下面就是非命名分组
        //1.matcher.group(0) 得到匹配到的字符串
        //2.matcher.group(1) 得到匹配的字符串的第1个分组内容
        //3.matcher.group(2) 得到匹配到的字符串的第2个分组内容
//        String regStr = "(\\d\\d)(\\d\\d)"; //匹配4个数字的字符串，分为两组
        //命名分组
        String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("匹配到的字符串："+matcher.group(0));
            System.out.println("匹配到的字符串第1组："+matcher.group(1));
            System.out.println("匹配到的字符串第1组："+matcher.group("g1"));
            System.out.println("匹配到的字符串第2组："+matcher.group(2));
            System.out.println("匹配到的字符串第2组："+matcher.group("g2"));
        }

        //演示非捕获分组
        String content = "hello 韩顺平教育 jack 韩顺平老师 韩顺平同学 hello 韩顺平学生";
        //找到 韩顺平教育、韩顺平老师、韩顺平同学
//        String regStr = "韩顺平教育|韩顺平老师|韩顺平同学";
        //上面的写法可以等价非捕获分组，注意：不能 matcher.group(1)
//        String regStr = "韩顺平(?:教育|老师|同学)";
        //找到 韩顺平这个关键字，但是要求只是查找韩顺平教育和韩顺平老师包含有的韩顺平
//        String regStr = "韩顺平(?=教育|老师)";
        //找到韩顺平这个关键字，但是要求只是查找 不是（韩顺平教育 和 韩顺平老师）中包含有的韩顺平
        String regStr = "韩顺平(?!教育|老师)";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()){
            System.out.println("找到："+matcher.group(0));
        }