第二十二章：正则表达式

代码界小菜鸟

于 2022-10-12 15:18:26 发布

阅读量315

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/m0_61927991/article/details/127275769

版权

java 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

一、正则的初体验

public static void main(String[] args) {
        String str = "Parsons 没有真正涉及很多的 JavaScript，但是 JavaScript 很吸引我，" +
                "因为它能够快速构建一些东西并分享给别人。把它放在网上，通过一个网址，任何有浏览器的人都可以看到。" +
                "这就是吸引我开始 Web 开发和 JavaScript 编程的原因";

        //1.先建一个pattern对象，模式对象，可以理解为一个正则表达式对象
        Pattern pattern = Pattern.compile("[a-zA-Z]+");
        //2.创建一个匹配器对象
        Matcher matcher = pattern.matcher(str);
        //3. 可以循环匹配
        while (matcher.find()){
            //匹配到的内容放到m.group(0)里面
            System.out.println(matcher.group(0));
        }
    }

二、正则表达式语法

（1）元字符-转义字符：\\

注意：java中\\代表去其他语言中的一个\,比如路径：src\\1.txt 。这些需要转义符：. + ( ) $ / \ ? [ ] ^ { } 。

public static void main(String[] args) {
        String str = "abc$.(abc(123";
        //匹配(
        String regStr = "\\(";  //单独写小括号是会报错的，需要转义字符串
//        String regStr = "\\$";  //单独写小括号是会报错的，需要转义字符串
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }

（2）元字符-字符匹配符：

public class Test {
    public static void main(String[] args) {
        String str = "a11c8abcABC @";
//        String regStr = "abc"; //区分大小写匹配 abc
//        String regStr = "(?i)abc"; //不区分abc大小写匹配
//        String regStr = "a(?i)bc"; //不区分bc大小写匹配
//        String regStr = "a((?i)b)c"; //不区分b大小写匹配
//        String regStr = "[0-9]"; //匹配 0 - 9 任意字符
//        String regStr = "[^a-z]"; //匹配 不在 a-z的字符
//        String regStr = "[^0-9]"; //匹配 不在 a-z的字符
//        String regStr = "[abcd]"; //匹配abcd任意字符
//        String regStr = "[^abcd]"; //匹配不是abcd任意字符
//        String regStr = "\\d"; //匹配是数字的任意字符
//        String regStr = "\\D"; //匹配不是数字的任意字符
//        String regStr = "\\w"; //匹配数字 大小英文字母 下划线
//        String regStr = "\\W"; //匹配不是数字 大小英文字母 下划线
//        String regStr = "\\s"; //匹配任意空白字符
//        String regStr = "\\S"; //匹配任意不是空白的字符
        String regStr ="."; // 匹配所有字符 除了\n,匹配本身需要\\.
        //1.当创建 Pattern.CASE_INSENSITIVE 表示不区分大小写匹配
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

（3）元字符-选择匹配符：

public class Test {
    public static void main(String[] args) {
        String str = "a11c8abcABC @";
        String regStr ="abc|@|1";
        //1.当创建 Pattern.CASE_INSENSITIVE 表示不区分大小写匹配
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

（4）元字符-限定符：用于指定前面字符出现多少次

public static void main(String[] args) {
        String str = "11111aaa1hello";
//        String regStr ="a{3}"; //相当于 aaa 表示匹配aaa
//        String regStr = "a{3,4}"; //java匹配默认，即尽可能匹配多的，表示匹配 aaa或aaaa
//        String regStr = "a+"; //表示匹配a个或多个a
//        String regStr ="a*"; //表示匹配0个或多个a
        String regStr = "a1?"; //匹配a或者a1
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }

（5）元字符-定位符

 public static void main(String[] args) {
        String str = "123 abc";
//        String regStr ="^[0-9]+[a-z]*";//匹配数字开头，后接任意个小写字符的字符串
//        String regStr = "^[0-9]+[a-z]+$";//匹配数字开头,必须以至少一个小写字母结束
//        String regStr = "[0-9]\\b";//边界
        String regStr = "[0-9]\\B";//边界
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }

（6）捕获分组：

public static void main(String[] args) {
        String str = "adwahdiu1232wdjawiod";
        //下面就是非命名分组，
        //说明：matcher.group(0) 得到匹配到的字符串
        //说明：matcher.group(1) 得到匹配到的字符串的第一个分组
        //说明：matcher.group(0) 得到匹配到的字符串的第二个分组
//        String regStr = "(\\d\\d)(\\d\\d)";

        //下面是命名分组
        String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
            System.out.println(matcher.group(1));
            System.out.println(matcher.group("g1")); //命名分组的捕获
            System.out.println(matcher.group(2));
            System.out.println(matcher.group("g2")); //命名分组的捕获
        }
    }

（7）非捕获分组：

public static void main(String[] args) {
        String str = "hello韩顺平教育 jack韩顺平老师 韩顺平同学hello";
        //下面是命名分组
//        String regStr = "韩顺平教育|韩顺平老师|韩顺平同学";
//        String regStr = "韩顺平(?:教育|老师|同学)"; //上面的写法等同于 非捕获分组
//        String regStr = "韩顺平(?=教育|老师)"; //不匹配括号里面的
        String regStr = "韩顺平(?!教育|老师)"; //韩顺平同学
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }

三、非贪婪匹配

public static void main(String[] args) {
        String str = "awdhkw1321adfjhakl";
//        String regStr = "\\d+"; //默认是贪婪匹配 1321
        String regStr = "\\d+?"; //改为非贪婪 匹配一个数字
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }

四、正则常用的三个类

（1）Pattern类：

public static void main(String[] args) {
        String str = "hello abc hello 韩顺平";
        String regStr = "hello";
        boolean matches = Pattern.matches(regStr, str);
        System.out.println(matches); //全文匹配
    }

（2）Matcher类：

public static void main(String[] args) {
        String str = "hello abc hello 韩顺平";
        String regStr = "hello";
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
            System.out.println(matcher.start()); //开始指针
            System.out.println(matcher.end()); //结束指针
        }
        System.out.println(matcher.matches()); //整体匹配
//        替换后的结果
        System.out.println(matcher.replaceAll("hello123"));
    }

五、反向引用

1.要匹配两个连续相同数字：(\\d)\\1

2.要匹配五个连续相同数字：(\\d)\\1\\1\\1\\1 === (\\d)\\1{4}

3.要匹配个位与千位相同，十位与百位相同的数 5225 , 1551 (\\d)(\\d)\\2\\1

解释：这里使用了分组 \\1表示引用第一个分组 \\2表示引用第二个分组

public class Test {
    public static void main(String[] args) {
        String str = "hello12312 111222 671267777789900";
//        String regStr = "(\\d)\\1"; //连续两个相同的数字
//        String regStr = "(\\d)\\1{4}"; //连续5个相同的数字
        String regStr = "(\\d)(\\d)\\2\\1"; //匹配个位等于千位 十位等于百位的数
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/); //这样也可以不区分大小写
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

六、在String类中使用正则表达式

public class Test {
    public static void main(String[] args) {
        String str = "hello12312 111222 671267777789900";
        boolean matches = str.matches("123");
        System.out.println(matches); //匹配是否全局含有123

        //分割字符串为数组
        String[] s = str.split("1|2|8"); //要求按照1、2、8分割
        System.out.println(Arrays.toString(s));
    }
}

代码界小菜鸟

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第二十二章：正则表达式

注意：java中\\代表去其他语言中的一个\,比如路径：src\\1.txt。这些需要转义符：. + ( ) $ / \?[ ] ^ { }。3.要匹配个位与千位相同，十位与百位相同的数 5225 , 1551 (\\d)(\\d)\\2\\1。2.要匹配五个连续相同数字：(\\d)\\1\\1\\1\\1 === (\\d)\\1{4}解释：这里使用了分组 \\1表示引用第一个分组 \\2表示引用第二个分组。1.要匹配两个连续相同数字：(\\d)\\1。
复制链接

扫一扫