正则表达式

已于 2024-07-15 18:17:51 修改
阅读量344 收藏 3
点赞数 12
分类专栏： JavaSE 文章标签： 正则表达式
于 2024-07-15 08:53:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79890350/article/details/140054058
版权

为什么要学习正则表达式

在这里插入图片描述

//体验正则表达式的威力，给我们文本处理带来哪些便利
public class Regexp_ {
    public static void main(String[] args) {
        //假定，编写了爬虫，从白度贝面得到如下文本
        String content =  "1995年，互联网的蓬勃发展给了Oak机会。业界为了使死板、单调的静态网页能够“灵活”起来，" +
                "急需一种软件技术来开发一种程序，这种程序可以通过网络传播并且能够跨平台运行。" +
                "于是，世界各大IT企业为此纷纷投入了大量的人力、物力和财力。这个时候，Sun公司想起了" +
                "那个被搁置起来很久的Oak，并且重新审视了那个用软件编写的试验平台，由于它是按照嵌入式系统硬件平台体系结构进行编写的，所以非常小，" +
                "特别适用于网络上的传输系统，而Oak也是一种精简的语言，程序非常小，适合在网络上传输。" +
                "Sun公司首先推出了可以嵌入网页并且可以随同网页在网络上传输的Applet（Applet是一种将小程序嵌入到网页中进行执行的技术），并将Oak更名为Java。" +
                "5月23日，Sun公司在Sun world会议上正式发布Java和HotJava浏览器。IBM、Apple、DEC、Adobe、HP、Oracle、Netscape和微软等各大公司" +
                "都纷纷停止了自己的相关开发项目，竞相购买了Java使用许可证，并为自己的产品开发了相应的Java平台";
        //提取文章中所有的英文单词
        //(1).传统方法。使用遍历方式，代码量大，效率不高
        //(2).正则表达式技术

        //1.先创建一个Pattern对象，模式对象，可以理解成就是一个正则表达式对象

        //提取文章中所有的英文单词
        //Pattern pattern = Pattern.compile("[a-zA-Z]+");

        //提取文章中所有的数字
        //Pattern pattern = Pattern.compile("[0-9]+");

        //提取文章中所有的英文单词和数字
        Pattern pattern = Pattern.compile("([0-9]+)|([a-zA-Z]+)");

        //2.创建一个匹配器对象
        //理解:就是 matcher 匹配器按照 pattern(模式/样式)，到content 文本中去匹配
        //找到就返回true，否则就返回false
        Matcher matcher = pattern.matcher(content);
        //3。可以开始循环匹配
        while(matcher.find()) {
            //匹配内容，文本，放到 m.group(0)
            System.out.println("找到:" + matcher.group(0));
        }
    }
}

正则表达式基本介绍

介绍

在这里插入图片描述

正则表达式底层实现(重要)

实例分析

为对正则表达式底层实现有一个直观的映象，举个实例
给一段字符串(文本)，请找出所有四个数字连在一起的子串， 比如:
应该找到 1998 1999 3443 9889 ==> 分析底层实现

/**
 * 分析 java 的正则表达式的底层实现(重要)
 */
public class RegTheory {
    public static void main(String[] args) {
        String content = "1998 年 12 月 8 日，第二代 Java 平台的企业版 J2EE 发布。1999 年 6 月，Sun 公司发布了" +
                "第二代 Java 平台（简称为 Java2）的 3 个版本：J2ME（Java2 Micro Edition，Java2 平台的微型" +
                "版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2 平台的" +
                "标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2 平台的企业版），应" +
                "用 3443 于基于 Java 的应用服务器。Java 2 平台的发布，是 Java 发展过程中最重要的一个" +
                "里程碑，标志着 Java 的应用开始普及 9889 ";
        //目标：匹配所有四个数字
        //说明
        //1. \\d 表示一个任意的数字
        //String regStr = "\\d\\d\\d\\d";
        String regStr = "(\\d\\d)(\\d\\d)";

        //2. 创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        //说明：创建匹配器 matcher， 按照 正则表达式的规则 去匹配 content 字符串
        Matcher matcher = pattern.matcher(content);

        //4.开始匹配

        /**
         *
         * matcher.find() 完成的任务 （考虑分组）
         * 什么是分组，比如 (\d\d)(\d\d) ,正则表达式中有() 表示分组,第 1 个()表示第 1 组,第 2 个()表示第 2 组...
         * 1. 根据指定的规则 ,定位满足规则的子字符串(比如(19)(98))
         * 2. 找到后，将 子字符串的开始的索引记录到 matcher 对象的属性 int[] groups;
         *      2.1 groups[0] = 0 , 把该子字符串的结束的索引+1 的值记录到 groups[1] = 4
         *      2.2 记录 1 组()匹配到的字符串 groups[2] = 0 groups[3] = 2 //(19)
         *      2.3 记录 2 组()匹配到的字符串 groups[4] = 2 groups[5] = 4 //(98)
         *      2.4.如果有更多的分组.....
         * 3. 同时记录 oldLast 的值为 子字符串的结束的 索引+1 的值即 35, 即下次执行 find 时，就从 35 开始匹配
         *
         * 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. 根据 groups[0]= 31 和 groups[1]=35 的记录的位置，从 content 开始截取子字符串返回
         *    就是 [31，35) 包含 31 但是不包含索引为 35 的位置
         *
         * 如果再次执行 find 方法.仍然按照上面分析来执行
         */

        while (matcher.find()) {
            //小结
            // 1. 如果正则表达式有() 即分组
            // 2. 取出匹配的字符串规则如下
            // 3. group(0) 表示匹配到的子字符串
            // 4. group(1) 表示匹配到的子字符串的第 1 组字串
            // 5. group(2) 表示匹配到的子字符串的第 2 组字串
            // 6. ... 但是分组的数不能越界

            System.out.println("找到: " + matcher.group(0));
            System.out.println("第 1 组()匹配到的值=" + matcher.group(1));
            System.out.println("第 2 组()匹配到的值=" + matcher.group(2));
            //System.out.println("第 3 组()匹配到的值=" + matcher.group(3)); //会报异常，越界

        }
    }
}

在这里插入图片描述

正则表达式语法

基本介绍

在这里插入图片描述

元字符(Metacharacter)-转义号 \\

在这里插入图片描述

//演示转义字符的使用
public class RegExp02 {
    public static void main(String[] args) {
        String content = "abc$(a.bc(123( )";
        //匹配( => \\(
        //String regStr = "\\(";
        //匹配. => \\.
        //String regStr = "\\.";
        //匹配 3个数字
        //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));
        }
    }
}

在这里插入图片描述

元字符-字符匹配符

在这里插入图片描述
在这里插入图片描述

//演示字符匹配符 的使用
public class RegExp03 {
    public static void main(String[] args) {
        String content = "a11c8abc _ABCy @";
        //String resStr = "[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 = "\\D";//匹配 不在 0-9 的任意一个字符
        //String regStr = "\\w";//匹配 大小写英文字母, 数字，下划线
        //String regStr = "\\W";//匹配 等价于 [^a-zA-Z0-9_]
        //String regStr = "\\s";//匹配 任何空白字符(空格,制表符等)
        //String regStr = "\\S";//匹配任何非空白字符 ,和 \\s 刚好相反
        String regStr = ".";//匹配出 \n 之外的所有字符,如果要匹配.本身则需要使用

        //说明
        //1. 当创建 Pattern 对象时，指定 Pattern.CASE_INSENSITIVE, 表示匹配是不区分字母大小写
        //Pattern pattern = Pattern.compile(regStr,Pattern.CASE_INSENSITIVE);
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

元字符-选择匹配符

在这里插入图片描述

public class RegExp04 {
    public static void main(String[] args) {
        String content = "hanshunping 韩 寒冷";
        String resStr = "han|韩|寒";
        Pattern pattern = Pattern.compile(resStr);
        Matcher matcher = pattern.matcher(content);

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

元字符-限定符

用于指定其前面的字符和组合项连续出现多少次
在这里插入图片描述
在这里插入图片描述

//演示限定符的使用
public class RegExp05 {
    public static void main(String[] args) {
        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 , 优先匹配 aaaa
        //String regStr = "1{4,5}"; //表示匹配 1111 或者 11111 , 优先匹配 11111
        //String regStr = "\\d{2,5}"; //匹配 2 位数或者 3,4,5 , 优先匹配 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));
        }
    }
}

元字符-定位符

定位符, 规定要匹配的字符串出现的位置，比如在字符串的开始还是在结束的位置
在这里插入图片描述

//演示定位符的使用
public class RegExp06 {
    public static void main(String[] args) {
        String content = "hanshunping sphan nnhan";
        //String content = "123-abc";
        //以至少 1 个数字开头，后接任意个小写字母的字符串
        //String regStr = "^[0-9]+[a-z]*";
        //以至少 1 个数字开头, 必须以至少一个小写字母结束
        //String regStr = "^[0-9]+[a-z]+$";
        //String regStr = "^[0-9]+\\-[a-z]+$"; // 同时中间得有 -
        //表示匹配边界的 han 【这里的边界是指：被匹配的字符串最后,也可以是空格的子字符串的后面】
        //String regStr = "han\\b";
        //和\\b 的含义刚刚相反
        String regStr = "han\\B";


        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

分组

在这里插入图片描述
在这里插入图片描述

//分组
public class RegExp07 {
    public static void main(String[] args) {
        String content = "hanshunping s7789 nn1189han";
        //String regStr = "\\d\\d\\d\\d";//匹配 4 个数字的字符串 , 无分组

        //下面就是非命名分组
        //说明
        // 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)";//匹配 4 个数字的字符串
        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"));
        }
    }
}

//演示非捕获分组, 语法比较奇怪
public class RegExp08 {
    public static void main(String[] args) {
        String content = "hello 韩顺平教育 jack 韩顺平老师 韩顺平同学 hello 韩顺平学生";
        //找到 韩顺平教育 、韩顺平老师、韩顺平同学 子字符串
        //String regStr = "韩顺平教育|韩顺平老师|韩顺平同学";
        //上面的写法可以等价非捕获分组, 注意：不能 matcher.group(1)
        //String regStr = "韩顺平(?:教育|老师|同学)";

        //找到 韩顺平 这个关键字,但是要求只是查找韩顺平教育和 韩顺平老师 中包含有的韩顺平
        //下面也是非捕获分组，不能使用 matcher.group(1)
        //String regStr = "韩顺平(?=教育|老师)"; // 两个韩顺平
        //String regStr = "韩顺平(?=教育)"; // 一个韩顺平

        //找到 韩顺平 这个关键字,但是要求只是查找 不是 (韩顺平教育 和 韩顺平老师) 中包含有的韩顺平
        //下面也是非捕获分组，不能使用 matcher.group(1)
        String regStr = "韩顺平(?!教育|老师)"; // 一个韩顺平（ 韩顺平同学 和 韩顺平学生 中的）
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

非贪婪匹配

public class RegExp09 {
    public static void main(String[] args) {
        String content = "hello111111 ok";
        //String regStr =  "\\d+"; //默认是贪婪匹配
        String regStr =  "\\d+?"; //非贪婪匹配

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到 " + matcher.group(0));
        }
    }
}
SHtop11
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最全csdn正则表达式
jingzhangnihao的博客
12-07 455
整数或者小数：^[0-9]+\.{0,1}[0-9]{0,2}$ 只能输入数字："^[0-9]*$"。 只能输入n位的数字："^\d{n}$"。 只能输入至少n位的数字："^\d{n,}$"。 只能输入m~n位的数字：。"^\d{m,n}$" 只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。 只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。
正则表达式语法+常用正则表达式
最新发布
SuperYang_的博客
07-05 735
1> 正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"），可以用来描述和匹配字符串的特定模式2> 正则表达式是一种用于模式匹配和搜索文本的工具3> 正则表达式提供了一种灵活且强大的方式来查找、替换、验证和提取文本数据4> 正则表达式可以应用于各种编程语言和文本处理工具中，如 JavaScript、Python、Java、Perl等。
csdn—正则表达式的最基础
夏天不能盖被子
06-22 848
代码的记忆，一直是一个问题。 像是正则表达式的代码的记忆。 总共就这两个东西。 可是因为最近的注意力底下。 学了又忘，真的是非常的糟糕的。 String text=”需要匹配的文本” String regex = “(\D*)(\d+)(.*)” Pattern pattern = Pattern.compile(regex); Matcher matcher = patter...
IP 正则表达式验证
12-12
您可能感兴趣的文章:javascript 手机号码正则表达式验证函数JS正则表达式验证数字代码JavaScript正则表达式验证身份证号码是否合法(两种方法)jquery正则表达式验证（手机号、身份证号、中文名称）邮箱地址正则...
正则表达式必知必会v_1.0.pdf
01-02
"正则表达式必知必会" 正则表达式是一种强大的文本处理工具，广泛应用于各个领域。下面是对正则表达式的详细解释： 正则表达式的用途 正则表达式主要用于处理文本，提供了两大主要功能：查找和替换。查找功能允许...
JavaScript正则表达式
01-08
1、正则表达式是描述字符模式的对象，正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。 2、String和RegExp都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 3、...
正则表达式匹配用户密码
12-13
正则表达式 ^[a-zA-Z]\w{5,17}$ 匹配 以字母开头，长度在6~18之间，只能包含字符、数字和下划线 不匹配 正则表达式 ^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?!.*\s).{4,8}$ 匹配 1agdA*$# | 1agdA*$# | 1agdA*$# 不...
正则表达式汇总-Labview
03-25
正则表达式汇总
正则表达式深入浅出：精通正则表达式的艺术
精通正则表达式第三版 正则表达式是计算机科学中的一种模式匹配语言，广泛应用于文本处理、数据提取、字符串匹配等领域。作为一名经验丰富的IT大师，我将从给定的文件中提炼出相关知识点，帮助读者更好地理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值