正则表达式

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

几个问题

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

四、应用实例

对字符串进行如下验证

        String content = "13588889999";
        //汉字
//        String regStr = "^[\u0391-\uffe5]+$";
        //邮编 要求是1-9开头的6位数
//        String regStr = "^[1-9]\\d{5}$";
        //qq号 1-9开头的5-10位数
//        String regStr = "^[1-9]\\d{4,9}$";
        //手机号 要求必须以13，14，15，18开头的11位数
        String regStr = "^1[3|4|5|8]\\d{9}$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        if(matcher.find()){
            System.out.println("满足格式");
        }else{
            System.out.println("不满足格式");
        }

    public static void main(String[] args) {
        //判断url
        String content =
                "https://www.bilibili.com/video/BV1fh411y7R8/?from=search&seid=1831060912083761326";
        /*
        思路：1.先确定url的开始部分
             2.然后匹配www.bilibili.com
             3.匹配/video/BV1fh411y7R8/?from=search
         */
        String regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        if(matcher.find()){
            System.out.println("满足格式");
        }else{
            System.out.println("不满足");
        }
        //这里使用Pattern的matches整体匹配比较简介
        System.out.println(Pattern.matches(regStr,content));
    }

五、正则表达式三个常用类

        String content = "hello abc hello, 韩顺平教育";
        String regStr = "hello.*";
        boolean matches = Pattern.matches(regStr, content);
        System.out.println(matches);

        String content = "hello edu jack hspedutom hello smith hello hspedu hspedu";
        String regStr = "hello";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
//        while (matcher.find()) {
//            System.out.println("=================");
//            System.out.println(matcher.start());
//            System.out.println(matcher.end());
//            System.out.println("找到: " + content.substring(matcher.start(), matcher.end()));
//        }
        //整体匹配方法，常用于，去校验某个字符串是否满足某个规则
        System.out.println("整体匹配=" + matcher.matches());
        //完成如果 content 有 hspedu 替换成 韩顺平教育
        regStr = "hspedu";
        pattern = Pattern.compile(regStr);
        matcher = pattern.matcher(content);
        //注意：返回的字符串才是替换后的字符串 原来的 content 不变化
        String newContent = matcher.replaceAll("韩顺平教育");
        System.out.println("newContent=" + newContent);
        System.out.println("content=" + content);

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

需求

• 给你一段文本，请你找出所有四个数字连在一起的子串，并且这四个数字要满足第1位和第4位相同，第2位和第3位相同

介绍

• 将 "我…我要…学学学学…编程 java!"改成”我要学编程java“

        String content = "我....我要....学学学学....编程 java!";
        //1.去掉所有的.
        Pattern pattern = Pattern.compile("\\.");
        Matcher matcher = pattern.matcher(content);
        content = matcher.replaceAll("");
//        System.out.println(content);
        //2.去掉重复的字
        //思路：(1)使用(.)\\1+       (2)使用反向引用$1 来替换匹配到的内容
//        pattern = Pattern.compile("(.)\\1+"); //分组的捕获内容记录到$1
//        matcher = pattern.matcher(content);
//        while (matcher.find()){
//            System.out.println(matcher.group(0));
//        }
//        //使用反向引用$1 来替换匹配到的内容
//        content = matcher.replaceAll("$1");
//        System.out.println(content);
        //3，使用一条语句去掉重复的字
        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
        System.out.println(content);

七、String类中使用正则表达式

        String content = "2000 年 5 月，JDK1.3、JDK1.4 和 J2SE1.3 相继发布，几周后其" +
                "获得了 Apple 公司 Mac OS X 的工业标准的支持。2001 年 9 月 24 日，J2EE1.3 发" +
                "布。" +
                "2002 年 2 月 26 日，J2SE1.4 发布。自此 Java 的计算能力有了大幅提升";
        //使用正则表达式，将JDK1.3和JDK1.4 替换成JDK
        content = content.replaceAll("JDK1\\.3|JDK1\\.4","JDK");
        System.out.println(content);
        //要求验证一个手机号 必须是138或139开头
        content = "13888889999";
        if(content.matches("1(38|39)\\d{8}")){
            System.out.println("正确");
        }else {
            System.out.println("失败");
        }
        //要求按照#或者-或者~或者数字来分割
        System.out.println("=============");
        content = "hello#abc-jack12smith~北京";
        String[] split = content.split("#|-|~|\\d+");
        for (String s: split) {
            System.out.println(s);
        }

八、练习题目

• 验证电子邮件格式是否合法

  1. 只能有一个@
  2. @前面是用户名，可以是a-z A-Z 0-9 _-字符
  3. @后面是域名，并且域名只能是英文字母，比如sohu.com 或者tsinghua.org.cn
  4. 写出对应的正则表达式，验证输入的字符串是否满足规则

• 验证是不是整数或者小数

  1. 考虑正数和负数
  2. 123 -345 34.89 -87.9 -0.01 0.45 等

• 对一个url进行解析

  1. 要求的协议是什么？
  2. 域名是什么
  3. 端口是什么
  4. 文件名是什么？