正则表达式（Java）（韩顺平笔记）

正则表达式（Java）

底层实现

package com.hspedu.RegExp;

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

public class RegExp00 {
    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平台" +
                "的企业版），应用于基于Java的应用服务器。Java 2平台的发布，是Java发展" +
                "过程中最重要的一个里程碑，标志着Java的应用开始普及。";
//        String regStr = "\\d\\d\\d\\d";
        String regStr = "(\\d\\d)(\\d\\d)";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        /**
         * matcher.find() 完成的任务
         * 1. 根据指定的规则，定位满足规则的子字符串(比如1998)
         * 2. 找到后，将子字符串的开始的索引记录到matcher对象的属性int[] groups;
         *    group[0] = 0, 把该子字符串的结束的索引+1的值记录到 groups[1] = 4;
         * 3. 同时记录 oldLast 的值为 子字符串的结束的 索引+1的值即4 即下次执行find时 就从4开始匹配
         *
         * matcher.find() 完成的任务
         * 1. 根据指定的规则，定位满足规则的子字符串(比如(19)(98))
         * 2. 找到后，将子字符串的开始的索引记录到matcher对象的属性int[] groups;
         *    2.1 group[0] = 0, 把该子字符串的结束的索引+1的值记录到 groups[1] = 4;
         *    2.2 记录1组的()匹配到的字符串 groups[2] = 0 groups[3] = 2
         *    2.3 记录2组的()匹配到的字符串 groups[4] = 2 groups[5] = 4
         * 3. 同时记录 oldLast 的值为 子字符串的结束的 索引+1的值即4 即下次执行find时 就从4开始匹配
         */
        while (matcher.find()) {
            System.out.println("找到:" + matcher.group(0));
            System.out.println("找到:" + matcher.group(1));//表示匹配到的子字符串的第一组子串
            System.out.println("找到:" + matcher.group(2));//表示匹配到的子字符串的第二组子串
            //分组不能越界
        }
    }
}

matcher.find

public boolean find() {
        int nextSearchIndex = last;
        if (nextSearchIndex == first)
            nextSearchIndex++;

        // If next search starts before region, start it at region
        if (nextSearchIndex < from)
            nextSearchIndex = from;

        // If next search starts beyond region then it fails
        if (nextSearchIndex > to) {
            for (int i = 0; i < groups.length; i++)
                groups[i] = -1;
            return false;
        }
        return search(nextSearchIndex);
    }

matcher.group

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

基础用法

package com.hspedu.RegExp;

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

public class RegExp01 {
    public static void main(String[] args) {
        String content = "a_bchHKKay66 66sABc_jdj*@fDH \n  Y298HU 寒冷 韩顺平 han";
//        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 = "[^0-9]";// 查找不在0-9任意一个字符
//        String regStr = "[^a-z]";// 查找不在a-z任意一个字符
//        String regStr = "[abcd]";// 查找abcd任意一个字符
//        String regStr = "[^abcd]";// 查找不是abcd任意一个字符
//        String regStr = "\\D";// 查找不是数字0-9字符
//        String regStr = "\\w";// 查找字母，数字，下划线  @不属于范围
//        String regStr = "\\W";// 上式取反 相当于[^0-9a-zA-Z_]
//        String regStr = "\\s";// 查找空白字符
//        String regStr = "\\S";// 查找非空白字符
//        String regStr = ".";// 查找非 \n 以外所有字符 查找.需要用 \\.

        String regStr = "寒|韩|han";// 选择匹配符


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

正则限定符

符号	含义	示例	说明	匹配输入
*	指定字符重复0次或n次（无要求）	(abc)*	仅包含任意个abc字符串，相当于\w*	abc abcabcabc
+	指定字符重复1次或n次（至少1次）	m+(abc)*	以至少1个m开头，后接任意个abc的字符串	m mabc mabcabc
?	指定字符重复0次或1次（最多1次）	m+abc?	以至少1个m开头，后接ab或abc的字符串	mab mabc mmmab mmabc
{n}	只能输入n个字符	[abcd]{3}	由abcd中字母组成的任意长度为3的字符串	abc dbc adc
{n,}	指定至少n个匹配	[abcd]{3,}	由abcd中字母组成的任意长度不小于3的字符串	aab dbc aaabdc
{n,m}	指定至少n个但不多于m个匹配	[abcd]{3,5}	由abcd中字母组成的任意长度不小于3，不大于5的字符串	abc abcd aaaaa bcdab

package com.hspedu.RegExp;

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

public class RegExp02 {
    public static void main(String[] args) {
        String content = "11111111aaaaaaahello";

//        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 实际 sout (找到 11111 (换行) 找到 111)

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

//        String regStr = "1*"; // 匹配0个1或者多个1

        String regStr = "a1?";// 匹配 a 或 a1

        Pattern pattern = Pattern.compile(regStr, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(content);

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

正则定位符

符号	含义	示例	说明	匹配输入
^	指定起始字符	1+[a-z]*	以至少一个数字开头，后接任意个小写字母的字符串	123 6aa 555edf
$	指定结束字符	2\\-[a-z]+$	以一个数字开头后接连字符“-”，并以至少1个小写字母结尾的字符串	1-a
\\b	匹配目标字符串的边界	han\\b	这里说的字符串边界指的是子串间有空格，或者是目标字符串的结束位置	hanshunping sphan nnhan
\\B	匹配目标字符串的非边界	han\\B	和\b的含义相反	hanshuping sphan nnhan

package com.hspedu.RegExp;

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

public class RegExp03 {
    public static void main(String[] args) {
//        String content = "123anj-556abc-945BGh";
//        String content = "123-ljj";
        String content = "hanshunping sphan nnhan";

//        String regStr = "^[0-9]+[a-z]*";// 找到123anj
//        String regStr = "^[0-9]+\\-[a-z]+$";// 找到123-ljj
//        String regStr = "^[0-9]+\\-[a-z]+$";// 找到123-ljj

//        String regStr = "han\\b";// 找到 han (sphan) 找到 han (nnhan)
        String regStr = "han\\B";// 找到 han (hanshunping)


        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

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

捕获分组

常用分组构造形式	说明
(pattern)	非命名捕获。捕获匹配的子字符串。编号为0的第一个捕获是由整个正则表达式模式匹配的文本，其他捕获结果则根据左括号的顺序从1开始自动编号。
(?'name’pattern)	命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中。用于name的字符串不能包含任何标点符号，并且不能以数字开头。可以使用尖括号代替单引号。

package com.hspedu.RegExp;

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

public class RegExp04 {
    public static void main(String[] args) {
        String content = "hanshunping s7789 nn1189han";

//        String regStr = "(\\d\\d)(\\d\\d)";//匹配四个数组的字符串(7789)(1189)

//        String regStr = "(\\d\\d)(\\d)(\\d)";
        /**
         * 找到 7789
         * 第一个分组 77
         * 第二个分组 8
         * 第三个分组 9
         * 找到 1189
         * 第一个分组 11
         * 第二个分组 8
         * 第三个分组 9
         */

        String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
        /**
         * 找到 7789
         * 第一个分组[编号] 77
         * 第二个分组[编号] 89
         * 找到 1189
         * 第一个分组[编号] 11
         * 第二个分组[编号] 89
         */

        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("g1"));
//            System.out.println("第二个分组 " + matcher.group(2));
            System.out.println("第二个分组[编号] " + matcher.group("g2"));
//            System.out.println("第三个分组 " + matcher.group(3));
        }
    }
}

非捕获分组

常用分组构造形式	说明
(?:pattern)	匹配pattern但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用“or”字符(|)组合模式部件的情况很有用。
(?=pattern)	它是一个非捕获匹配。
(?!pattern)	该表达式匹配不处于匹配pattern的字符串的起始点的搜索字符串。

package com.hspedu.RegExp;

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

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

        String content = "hello韩顺平教育 Jack韩顺平老师 韩顺平同学hello";
        //找到 韩顺平教育 、 韩顺平老师 、 韩顺平同学
//        String regStr = "韩顺平(?:教育|老师|同学)";//不能group(1)

        //找到 韩顺平教育中的韩顺平 韩顺平老师中的韩顺平
//        String regStr = "韩顺平(?=教育|老师)";

        //找到 不是韩顺平教育中的韩顺平 不是韩顺平老师中的韩顺平
        String regStr = "韩顺平(?!教育|老师)";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            //非捕获分组 不能使用group(1)
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

非贪婪匹配

package com.hspedu.RegExp;

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

public class RegExp06 {
    public static void main(String[] args) {
        
        String content = "hello1111111";
        String regStr = "\\d+?";
        
        /**
         * 找到 1
         * 找到 1
         * 找到 1
         * 找到 1
         * 找到 1
         * 找到 1
         * 找到 1
         */
        
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            //非捕获分组 不能使用group(1)
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

应用实例

package com.hspedu.RegExp;

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

public class RegExp07 {
    public static void main(String[] args) {
        //汉字
//        String content = "韩顺平教育";
//        String regStr = "^[\u0391-\uffe5]+$";//true

        //1-9开头的一个六位数
//        String content = "112344";
//        String regStr = "^[1-9]\\d{5}$";//true

        //1-9开头的一个(5-10位数)
//        String content = "12389";
//        String regStr = "^[1-9]\\d{4,9}$";//true

        //以11、13、18开头的11位数
        String content = "11588889999";
        String regStr = "^1[1|3|8]\\d{9}$";//true

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        if (matcher.find()) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }

    }
}

验证复杂URL

package com.hspedu.RegExp;

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

public class RegExp09 {
    public static void main(String[] args) {
        String content = "https://www.bilibili.com/video/BV1fh411y7R8?;
        /** ((http|https)://)开始部分
         *  ([\w-]+\.)+[\w-]+ 匹配 www.bilibili.com
         *  (\/[\w-?=&/%.#]*)? 匹配 /video/BV1fh411y7R8?p=894&vd_source=a8223634aa8a190c7233a2dc3f8a15e3
         *  []里面的元素相当于一个集合
         *  如果查找 "(去掉http)edu.metastudy.vip/mt/official/pc/mxmt-ksjhdj"
         *  regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";
         */

        String regStr = "^((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        if (matcher.find()) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

Pattern类matches方法

package com.hspedu.RegExp;

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

public class RegExp10 {
    public static void main(String[] args) {
        String content = "10https://www.bilibili.com/video/BV1fh411y7R8?p=894&vd_source=";

        String regStr = "((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        //find匹配必须加^$定位符
        if (matcher.find()) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }

        //整体匹配
        System.out.println(Pattern.matches(regStr, content));

        /**
         * true
         * false
         */
    }
}

Pattern类中的源码：

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

matcher方法

package com.hspedu.RegExp;

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

public class RegExp11 {
    public static void main(String[] args) {
        String content = "hello edu jack hspedutom hello smith hello";
//        String regStr = "hello";
        String regStr = "hello edu jack tom hello smith 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());

        regStr = "hspedu";
        pattern = Pattern.compile(regStr);
        matcher = pattern.matcher(content);

        String newContent = matcher.replaceAll("韩顺平教育");//并没有改变原来的content
        System.out.println("content = " + content);
        System.out.println("new = " + newContent);

    }
}

反向引用

1. 分组 可以使用()组成一个比较复杂的匹配模式，一个圆括号的部分我们可以看作一个子表达式/一个分组
2. 捕获 把正则表达式中子表达式/分组匹配内容，保存到一个组里，方便后面引用 0代表整个表达式
3. 反向引用 圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式

package com.hspedu.RegExp;

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

public class RegExp12 {
    public static void main(String[] args) {
        String content = "hello hspedu11111 hello22 12345-111222333";

        //找到两个连续相同的数字
//        String regStr = "(\\d)\\1";

        //找到五个连续相同的数字
//        String regStr = "(\\d)\\1{4}";

        //找到个位与千位相同 十位与百位相同的数字
//        String regStr = "(\\d)(\\d)\\2\\1";

        //找到以下格式 "五位数-九位数连续每三位相同(例如：12345-111222333)"
        String regStr = "\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

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

替换分割匹配

package com.hspedu.RegExp;

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

public class RegExp13 {
    public static void main(String[] args) {
        String content = "我....我要....学学学学....编程java!";

        //去掉所有的 .
        Pattern pattern = Pattern.compile("\\.");
        Matcher matcher = pattern.matcher(content);
        content = matcher.replaceAll("");

        System.out.println("content=" + content);

        //去掉重复的字 (.)查找任意的字符 \\1反向引用出'(.)'的内容 +指重复多次 $1表示重复字符替换为1个
        //如果要替换ABAB型 例如"我要我要" 使用(..)\\1+
        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");

        System.out.println("content=" + content);
    }
}

练习题

package com.hspedu.RegExp;

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

public class RegExpHomework {
    public static void main(String[] args) {
        //匹配电子邮箱 例如 shu@sohu.com shu@sougo.org.cn
        String content01 = "shu@sougo.org.cn";

        //[\\w-](@前面的英文) @([a-zA-z]+\.)(至少匹配一次@英文.)
        String regStr01 = "^[\\w-]+@([a-zA-z]+\\.)+[a-zA-Z]+$";

        if (content01.matches(regStr01)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }

        //匹配整数或者小数
        String content02 = "-0.56";

        //([1-9]\d*|0)判断整数部分 不能出现0034.56
        String regStr02 = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";

        if (content02.matches(regStr02)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }

        //解析url
        String content03 = "http://www.sohu.com:8080/abc/index.html";

        String regStr03 = "^([a-zA-Z]+)://([a-zA-Z.]+):(\\d+)[\\w-/]*/([\\w.]+)$";

        Pattern pattern = Pattern.compile(regStr03);
        Matcher matcher = pattern.matcher(content03);

        if (matcher.matches()) {
            System.out.println("true");
            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));
        } else {
            System.out.println("false");
        }
    }
}

---

1. 0-9 ↩︎

2. 0-9 ↩︎