掌握正则表达式：从入门到精通的实战指南

在这里插入图片描述

文章目录

🌍一.正则表达式
❄️1.为什么学习正则表达式
❄️ 2.基本介绍
❄️3.分析底层实现

🌍二.正则表达式的语法
❄️1.字符匹配
❄️2.量词
❄️3.定位符
4.分组和引用
❄️6.非贪婪匹配
❄️7.分支结构
❄️实际应用

🌍 三.正则标表达式的三个常用类
❄️1. Pattern类
❄️2.Matcher类
❄️3.PatternSyntaxException

🌍 四.分组,捕获,反向引用
❄️提出问题
❄️了解正则表达式的几个概念
❄️经典的结巴程序

🌍五.String类中使用正则表达式
❄️1.替换功能
❄️2.判断功能
❄️3.分割功能
❄️4.演示代码

🌍六.Java正则表达式大全
❄️一、校验数字的表达式
❄️二、校验字符的表达式
❄️三、特殊需求表达式

🌍七.题目练习
❄️第一题
❄️第二题
❄️第三题

🙋‍♂️ 作者：@whisperrr.🙋‍♂️

🎉 其他专栏：零基础学Mysql 🎉

💥 标题：掌握正则表达式：从入门到精通的实战指南💥

❣️ 寄语：比较是偷走幸福的小偷❣️

🌍一.正则表达式

❄️1.为什么学习正则表达式

我们先来看几个问题。

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

解决之道，就在其中-----正则表达式。

❄️ 2.基本介绍

正则表达式（Regular Expression）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。正则表达式用于执行字符串的搜索和/或替换操作，常用于数据验证、数据抓取、数据整理等场景。
简单的说：正则表达式是对字符串执行模式匹配的技术。

❄️3.分析底层实现

matcher.find()

matcher.find()完成的任务

根据指定的规则，定位满足规则的子字符串（比如1234）
找到后，将子字符串的索引位置记录到matcher对象的属性int [] groups;
groups[0] = 0, 把该子字符串的结束索引 + 1 记录到groups[1] = 4;
同时记录oldlast 的值为子字符串的结束索引 + 1即为4;

matcher.group(0)

   public String group(int group) {
        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();
    }

        小结
        1.如果正则表达式有（）分组
        2.group（0）代表匹配的子字符串
        2.group（1）代表匹配的子字符串的第一组
        2.group（2）代表匹配的子字符串的第二组

在这里插入图片描述

🌍二.正则表达式的语法

正则表达式（Regular Expression）是一种强大的文本处理工具，它通过定义一种规则来对字符串进行模式匹配、搜索和替换。下面我会详细讲解正则表达式的各个方面。

❄️1.字符匹配

.：匹配除换行符之外的任意单个字符。
[abc]：匹配方括号内的任意一个字符（a、b 或 c）。
[^abc]：匹配不在方括号内的任意一个字符。
[a-z]：匹配从 a 到 z 的任意一个小写字母。
[A-Z]：匹配从 A 到 Z 的任意一个大写字母。
[0-9]：匹配从 0 到 9 的任意一个数字。
\d：匹配一个数字字符。等价于 [0-9]。
\D：匹配一个非数字字符。等价于 [^0-9]。
\w：匹配包括下划线的任何单词字符。等价于 [A-Za-z0-9_]。
\W：匹配任何非单词字符。等价于 [^A-Za-z0-9_]。
\s：匹配任何空白字符，包括空格、制表符、换行符等等。
\S：匹配任何非空白字符。

❄️2.量词

*：匹配前面的子表达式零次或多次。
+：匹配前面的子表达式一次或多次。
?：匹配前面的子表达式零次或一次。
{n}：n 是一个非负整数，匹配确定的 n 次。
{n,}：至少匹配 n 次。
{n,m}：至少匹配 n 次且最多匹配 m 次。

❄️3.定位符

^：匹配输入字符串的开始位置。
$：匹配输入字符串的结束位置。
\b：匹配一个单词边界，即字与空格间的位置。
\B：匹配非单词边界。

4.分组和引用

(exp)：匹配 exp 并捕获文本到自动命名的组里。
(?:exp)：匹配 exp 但不捕获匹配的文本。
\n：引用编号为 n 的捕获组匹配的文本。

❄️6.非贪婪匹配

默认情况下，量词都是贪婪的，会尽可能多地匹配字符。在量词后面加上 ? 可以使其变为非贪婪的，即尽可能少地匹配字符。

*?：非贪婪地匹配任意次。
+?：非贪婪地匹配一次或多次。
??：非贪婪地匹配零次或一次。
{n,m}?：非贪婪地至少匹配 n 次且最多匹配 m 次。

❄️7.分支结构

可以使用 | 来表示分支结构，匹配符号左边的子表达式或右边的子表达式。

foo|bar：匹配 “foo” 或 “bar”。

❄️实际应用

在不同的编程语言中，正则表达式的语法和功能可能会有所不同，但基本概念是通用的。以下是一些使用正则表达式的例子：

package com.lrx.regexp;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author 刘
 * @version 1.0
 */
public class RegExp08 {
    public static void main(String[] args) {

        String content = "https://www.bilibili.com/video/BV1oDU4YYEgT/?spm_id_from=333.1007.tianma.4-4-14.click";
        String regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+([\\w-#%&?.=/]*)?$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);	
        //第一种验证方法
        while(matcher.find()) {
            System.out.println(matcher.group(0));
        }
        if(matcher.find()) {
            System.out.println("找到");
        }else {
            System.out.println("没有");
        }
        //第二种验证方法
        boolean matches = Pattern.matches(regStr, content);
        System.out.println(matches);
    }
 }

🌍 三.正则标表达式的三个常用类

java.util.regex包主要包括以下三个类Pattern类、Matcher类和PatternSyntaxException

❄️1. Pattern类

pattern对象是一个正则表达式对象。Pattern类没有公共构造方法。要创建一个Pattern对象，调用其公共静态方法，它返回一个Pattern对象。该方法接受一个正则表达式作为它的第一个参数，比如：Pattern r=Pattern.compile(pattern);

Pattern类的方法matcher,应用于整体匹配,匹配一部分是错误，验证某一个字符串是否匹配某种规则
看一下matcher底层实现

public static boolean matches(String regex, CharSequence input) {
                Pattern p = Pattern.compile(regex);
                 Matcher m = p.matcher(input);
                return m.matches();
            }

❄️2.Matcher类

Matcher对象是对输入字符串进行解释和匹配的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用Pattern对象的matcher方法来获得一个Matcher对象

matcher.matches()整体匹配规则，常用于去校验某个字符串是否满足某个规则
matcher.replaceAll(“张”)完成替换方法，注意，不是在原字符串上面替换，而是返回一个替换后的字符串

❄️3.PatternSyntaxException

PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

🌍 四.分组,捕获,反向引用

❄️提出问题

给你一段文本，请你找出所有四个数字连在一起的子串，并且这四个数字要满足①第1位与第4位相同②第2位与第3位相同，比如1221,5775,…

❄️了解正则表达式的几个概念

分组我们可以用圆括号组成一个比较复杂的匹配模式，那么一个圆括号的部分我们可以看作是一个子表达式/一个分组。
捕获把正则表达式中子表达式/分组匹配的内容，保存到内存中以数字编号或显式命名的组里，方便后面引用，从左向右，以分组的左括号为标志，第一个出现的分组的组号为1,第二个为2,以此类推。组0代表的是整个正则式
反向引用圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以是在正则表达式内部，也可以是在正则表达式外部，内部反向引用 \\分组号，外部反向引用 $ 分组号

上面的问题这里不过多叙述，看下面一个经典的结巴程序

❄️经典的结巴程序

问题：
把类似 : “我…我要…学学学学…编程 java!”;通过正则表达式修改成 “我要学编程 java”

package com.lrx.regexp;

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

/**
 * @author 刘
 * @version 1.0
 */
public class RegExp09 {
    public static void main(String[] args) {
        String content = "我...我要...学学学....编程Java";

        //1.去掉.
        String regStr = "\\.";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        content = matcher.replaceAll("");
        System.out.println(content);

        //2.去掉重复的字
//        regStr = "(.)\\1+";
//        pattern = Pattern.compile(regStr);
//        matcher = pattern.matcher(content);
//        content = matcher.replaceAll("$1");
//        System.out.println(content);

        //3.也可以使用一句语句
        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
        System.out.println(content);

    }
 }

🌍五.String类中使用正则表达式

❄️1.替换功能

String 类 public String replaceAll(String regex,String replacement)
底层代码:

public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

❄️2.判断功能

String 类 public boolean matches(String regex){} //使用 Pattern 和 Matcher 类
底层代码:

 public static boolean matches(String regex, CharSequence input) {
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(input);
        return m.matches();
    }

❄️3.分割功能

String 类 public String[] split(String regex)
底层代码:

  public String[] split(String regex) {
        return split(regex, 0);
    }

❄️4.演示代码

使用正则表达式方式，将 JDK1.3 和 JDK1.4 替换成 JDK
要求验证一个手机号，要求必须是以 138 139 开头的
要求按照 # 或者 - 或者 ~ 或者数字来分割

public class StringReg {
    public static void main(String[] args) {
        String content = "2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，" +
                "几周后其获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，" +
                "J2EE1.3发布。2002年2月26日，J2SE1.4发布。";
       
        content = content.replaceAll("JDK1\\.3|JDK1\\.4","JDK");
        System.out.println(content);

        content = "13812341234";
        boolean matches = content.matches("(1(38|39))\\d{8}");
        System.out.println(matches);


        content = "je#jjj-oo~999aaa";
        String[] split = content.split("#|-|~|\\d+");
        for (String s : split) {
            System.out.println(s);
        }

    }
}

🌍六.Java正则表达式大全

❄️一、校验数字的表达式

1 数字：¹$
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]{2})?$
10 有1~3位小数的正实数：³+(.[0-9]{1,3})?$
11 非零的正整数：⁴\d$ 或 ^([1-9][0-9]){1,3}$ 或 ^+?[1-9][0-9]$
12 非零的负整数：^-[1-9][]0-9"$ 或 ^-[1-9]\d$
13 非负整数：^\d+$ 或 ⁵\d*|0$
14 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
15 非负浮点数：^\d+(.\d+)?$ 或 ⁶\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 正浮点数：⁷\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 汉字：⁸{0,}$
2 英文和数字：⁹+$ 或 ¹⁰{4,40}$
3 长度为3-20的所有字符：^.{3,20}$
4 由26个英文字母组成的字符串：¹¹+$
5 由26个大写英文字母组成的字符串：¹²+$
6 由26个小写英文字母组成的字符串：¹³+$
7 由数字和26个英文字母组成的字符串：¹⁴+$
8 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
9 中文、英文、数字包括下划线：¹⁵+$
10 中文、英文、数字但不包括下划线等符号：¹⁶+$ 或 ¹⁷{2,20}$
11 可以输入含有^%&',;=? $KaTeX parse error: Expected group after '^' at position 8: \"等字符：[^̲%&',;=?$ \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位身份证：¹⁸\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$
18位身份证：¹⁹\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-Z0-9_]{4,15}$
10 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：²¹\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”：²²[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]+)?$
20 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 “10” 和 “10.2” 是通过的：²⁴+(.[0-9]{2})?$
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：²⁵+(.[0-9]{1,2})?$
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：²⁶{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* $KaTeX parse error: Undefined control sequence: \s at position 4: 或(^\̲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地址时有用)

🌍七.题目练习

❄️第一题

验证电子邮件格式是否合法,规定电子邮件规则为

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

public class HomeWork01 {
    public static void main(String[] args) {
        String content = "12aA_@sohZu.cZom";
        boolean matches = content.matches("^[\\w-]+@(([a-zA-Z])+\\.)+[a-zA-Z]+$");
        System.out.println(matches);
    }
}

❄️第二题

要求验证是不是整数或者小数
提示：这个题要考虑正数和负数比如：123-34534.89-87.9-0.010.45等

public class HomeWork02 {
    public static void main(String[] args) {
        String content = "00.1";
        boolean matches = content.matches("^[-+]?([1-9\\d+|0])(\\.\\d+)?$");
        System.out.println(matches);
    }
}

❄️第三题

对一个url进行解析http://www.sohu.com:8080/abc/index.htm
a)要求得到协议是什么?
b)域名是什么?
c)端口是什么?
d)文件名是什么?

public class HomeWork03 {
    public static void main(String[] args) {

        String content = "http://www.sohu.com:8080/abc/index.htm";
        String regStr = "^((http|https)://)?([a-zA-Z.]+):(\\d+)([\\w/]*)/([\\w.]+)$";
        Pattern pattern = Pattern.compile(regStr);
        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));
            System.out.println(matcher.group(3));
            System.out.println(matcher.group(4));
            System.out.println(matcher.group(5));
            System.out.println(matcher.group(6));
        }
    }
}