正则表达式

# 正则表达式

入门体验：

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 */
public class Regexp_ {
    public static void main(String[] args) {
        String content ="</i><span class=\"refresh-text_1-d1i\">换一换</span></a></div>" +
                "</div><div class=\"opr-toplist1-table_3K7iH\"><div>" +
                "<div class=\"toplist1-tr_4kE4D\">" +
                "<div class=\"toplist1-td_3zMd4 opr-toplist1-link_2YUtD\">" +
                "<span class=\"c-index-single toplist1-hot_2RbQT  c-color-red toplist1-hot-normal_12THH\" style=\"opacity:1;\"><i class=\"c-icon icon-top_4eWFz\">\uE662</i></span><a target=\"_blank\" title=\"中国探月未来已来\" href=\"/s?wd=%E4%B8%AD%E5%9B%BD%E6%8E%A2%E6%9C%88%E6%9C%AA%E6%9D%A5%E5%B7%B2%E6%9D%A5&amp;rsv_idx=2&amp;tn=baiduhome_pg&amp;usm=6&amp;ie=utf-8&amp;rsv_pq=a0a7c60a000bb8de&amp;oq=1&amp;rsv_t=c46eXOFH6I1ZTI4TBKaqzEMnM2CSghlBdsza4L85Px5VaFjdgenaUxdgvyVpPKy4Apyn&amp;rqid=a0a7c60a000bb8de&amp;rsf=6b09c17bb5c330f4b81b97b89bec9db9_1_15_1&amp;rsv_dl=0_right_fyb_pchot_20811&amp;sa=0_right_fyb_pchot_20811\" class=\"c-font-medium c-color-t opr-toplist1-subtitle_3FULy\" data-click=\"{&#39;clk_info&#39;: &#39;index: 1, page: 1&#39;}\">中国探月未来已来</a></div></div><div class=\"toplist1-tr_4kE4D\"><div class=\"toplist1-td_3zMd4 opr-toplist1-link_2YUtD\"><span class=\"c-index-single toplist1-hot_2RbQT   c-index-single-hot1\" style=\"opacity:1;\">1</span><a target=\"_blank\" title=\"乌方：乌军已突破至乌俄边境地区\" href=\"/s?wd=%E4%B9%8C%E6%96%B9%EF%BC%9A%E4%B9%8C%E5%86%9B%E5%B7%B2%E7%AA%81%E7%A0%B4%E8%87%B3%E4%B9%8C%E4%BF%84%E8%BE%B9%E5%A2%83%E5%9C%B0%E5%8C%BA&amp;rsv_idx=2&amp;tn=baiduhome_pg&amp;usm=6&amp;ie=utf-8&amp;rsv_pq=a0a7c60a000bb8de&amp;oq=1&amp;rsv_t=c46eXOFH6I1ZTI4TBKaqzEMnM2CSghlBdsza4L85Px5VaFjdgenaUxdgvyVpPKy4Apyn&amp;rqid=a0a7c60a000bb8de&amp;rsf=6b09c17bb5c330f4b81b97b89bec9db9_1_15_2&amp;rsv_dl=0_right_fyb_pchot_20811&amp;sa=0_right_fyb_pchot_20811\" class=\"c-font-medium c-color-t opr-toplist1-subtitle_3FULy\" data-click=\"{&#39;clk_info&#39;: &#39;index: 2, page: 1&#39;}\">乌方：乌军已突破至乌俄边境地区</a><span class=\"c-text c-text-hot opr-toplist1-label_3Mevn\">热</span></div></div><div class=\"toplist1-tr_4kE4D\"><div class=\"toplist1-td_3zMd4 opr-toplist1-link_2YUtD\"><span class=\"c-index-single toplist1-hot_2RbQT   c-index-single-hot2\" style=\"opacity:1;\">2</span><a target=\"_blank\" title=\"外籍男子骚扰女性被拘7日限期出境\" href=\"/s?wd=%E5%A4%96%E7%B1%8D%E7%94%B7%E5%AD%90%E9%AA%9A%E6%89%B0%E5%A5%B3%E6%80%A7%E8%A2%AB%E6%8B%987%E6%97%A5%E9%99%90%E6%9C%9F%E5%87%BA%E5%A2%83&amp;rsv_idx=2&amp;tn=baiduhome_pg&amp;usm=6&amp;ie=utf-8&amp;rsv_pq=a0a7c60a000bb8de&amp;oq=1&amp;rsv_t=c46eXOFH6I1ZTI4TBKaqzEMnM2CSghlBdsza4L85Px5VaFjdgenaUxdgvyVpPKy4Apyn&amp;rqid=a0a7c60a000bb8de&amp;rsf=6b09c17bb5c330f4b81b97b89bec9db9_1_15_3&amp;rsv_dl=0_right_fyb_pchot_20811&amp;sa=0_right_fyb_pchot_20811\" class=\"c-font-medium c-color-t opr-toplist1-subtitle_3FULy\" data-click=\"{&#39;clk_info&#39;: &#39;index: 3, page: 1&#39;}\">外籍男子骚扰女性被拘7日限期出境</a><span class=\"c-text c-text-hot opr-toplist1-label_3Mevn\">热</span></div></div><div class=\"toplist1-tr_4kE4D\"><div class=\"toplist1-td_3zMd4 opr-toplist1-link_2YUtD\"><span class=\"c-index-single toplist1-hot_2RbQT   c-index-single-hot3\" style=\"opacity:1;\">3</span><a target=\"_blank\" title=\"消防员为震区老乡手写感谢信\" href=\"/s?wd=%E6%B6%88%E9%98%B2%E5%91%98%E4%B8%BA%E9%9C%87%E5%8C%BA%E8%80%81%E4%B9%A1%E6%89%8B%E5%86%99%E6%84%9F%E8%B0%A2%E4%BF%A1&amp;rsv_idx=2&amp;tn=baiduhome_pg&amp;usm=6&amp;ie=utf-8&amp;rsv_pq=a0a7c60a000bb8de&amp;oq=1&amp;rsv_t=c46eXOFH6I1ZTI4TBKaqzEMnM2CSghlBdsza4L85Px5VaFjdgenaUxdgvyVpPKy4Apyn&amp;rqid=a0a7c60a000bb8de&amp;rsf=6b09c17bb5c330f4b81b97b89bec9db9_1_15_4&amp;rsv_dl=0_right_fyb_pchot_20811&amp;sa=0_right_fyb_pchot_20811\" class=\"c-font-medium c-color-t opr-toplist1-subtitle_3FULy\" data-click=\"{&#39;clk_info&#39;: &#39;index: 4, page: 1&#39;}\">消防员为震区老乡手写感谢信</a></div></div><div class=\"toplist1-tr_4kE4D\"><div class=\"toplist1-td_3zMd4 opr-toplist1-link_2YUtD\"><span class=\"c-index-single toplist1-hot_2RbQT   toplist1-hot-normal_12THH\" style=\"opacity:1;\">4</span><a target=\"_blank\" title=\"老人赶集卖的鸭被闷死 路人纷纷买下\" href=\"/s?wd=%E8%80%81%E4%BA%BA%E8%B5%B6%E9%9B%86%E5%8D%96%E7%9A%84%E9%B8%AD%E8%A2%AB%E9%97%B7%E6%AD%BB%20%E8%B7%AF%E4%BA%BA%E7%BA%B7%E7%BA%B7%E4%B9%B0%E4%B8%8B&amp;rsv_idx=2&amp;tn=baiduhome_pg&amp;usm=6&amp;ie=utf-8&amp;rsv_pq=a0a7c60a000bb8de&amp;oq=1&amp;rsv_t=e966suftTwhfvF%2B4kx5q4iSVPInibMp2RJIAQrHE1aaQeK8zR51%2BAbjkA%2BhyOju979wr&amp;rqid=a0a7c60a000bb8de&amp;rsf=6b09c17bb5c330f4b81b97b89bec9db9_1_15_5&amp;rsv_dl=0_right_fyb_pchot_20811&amp;sa=0_right_fyb_pchot_20811\" class=\"c-font-medium c-color-t opr-toplist1-subtitle_3FULy\" data-click=\"{&#39;clk_info&#39;: &#39;index: 5, page: 1&#39;}\">老人赶集卖的鸭被闷死 路人纷纷买下</a></div>;

        //1. 先创建一个 Pattern 对象 ， 模式对象, 可以理解成就是一个正则表达式对象
        // Pattern pattern = Pattern.compile("[a-zA-Z]+");
        // Pattern pattern = Pattern.compile("[0-9]+");
        // Pattern pattern = Pattern.compile("([a-zA-Z]+)|([0-9]+)");
        Pattern pattern = Pattern.compile("a target=\"_blank\" title=\"(\\S*)\"");
        Matcher matcher = pattern.matcher(content);
        int i = 0;
        while (matcher.find()) {
            //System.out.println((++i) + ":" + matcher.group(0));
            System.out.println((++i) + ":" + matcher.group(1));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 正则表达式底层实现

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 析 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)";
        //2. 创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        // 说明：创建匹配器 matcher， 按照 正则表达式的规则 去匹配 content 字符串
        Matcher matcher = pattern.matcher(content);

        /**
         * 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
         *  2.3 记录 2 组()匹配到的字符串 groups[4] = 2 groups[5] = 4
         *  2.4.如果有更多的分组.....
         * 3. 同时记录 oldLast 的值为 子字符串的结束的 索引+1 的值即 35, 即下次执行 find 时，就从 35 开始匹 配
         *     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]=0 和 groups[1]=2 的记录的位置，从 content 开始截取子字符串返回
         *     就是 [0,2) 包含 0 但是不包含索引为 2 的位置
         */
        while (matcher.find()) {
            //1. 如果正则表达式有() 即分组
            // 2. 取出匹配的字符串规则如下
            // 3. group(0) 表示匹配到的子字符串
            // 4. group(1) 表示匹配到的子字符串的第一组字串
            // 5. group(2) 表示匹配到的子字符串的第 2 组字串
            System.out.println(matcher.group(0));
            System.out.println("第一组: " + matcher.group(1));
            System.out.println("第二组: " + matcher.group(2));
        }
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# 正则表达式语法

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

# 元字符-字符匹配符

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 字符匹配符 的使用
 */
public class RegExp02 {
    public static void main(String[] args) {
        String content = "a11c8abc _ABCy @\n";
        //String regStr = "[a-z]"; //匹配 a-z 之间任意一个字符
        //String regStr = "[A-Z]"; //匹配 A-Z 之间任意一个字符
        //String regStr = "abc"; //匹配 abc 字符串[默认区分大小写]
        //String regStr = "(?i)abc"; //匹配 abc 字符串[不区分大小写]
        //String regStr = "a((?i)b)c"; // b不区分大小写
        //String regStr = "[0-9]"; //匹配 0-9 之间任意一个字符
        //String regStr = "[^a-z]" ;//匹配 不在 a-z 之间任意一个字符
        //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";//\\s 匹配任何空白字符(空格,制表符等)

        //\\S 匹配任何非空白字符 ,和\\s 刚好相反
        //String regStr = "\\S";
        //. 匹配除 \n 之外的所有字符,如果要匹配.本身则需要使用 \\.
        String regStr = ".";

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

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 元字符-选择匹配符

# 元字符-限定符

用于指定其前面的字符和组合项连续出现多少次

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 限定符的使用
 */
public class RegExp03 {
    public static void main(String[] args) {
        String content = "a211111aaaaaahello";
        //a{3},1{4},\\d{2}
        // 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
        // String regStr = "1+"; //匹配一个 1 或者多个 1
        // String regStr = "\\d+"; //匹配一个数字或者多个数字
        //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));
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 元字符-定位符

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 定位符的使用
 */
public class RegExp04 {
    public static void main(String[] args) {
        String content = "123-abc";
        // 以至少 1 个数字开头，后接任意个小写字母的字符串
        // String regStr = "^[0-9][a-z]*";
        //以至少 1 个数字开头, 必须以至少一个小写字母结束
        //String regStr = "^[0-9]+\\-[a-z]+$";

        //表示匹配边界的 abc[这里的边界是指：被匹配的字符串最后, 也可以是空格的子字符串的后面]
        //String regStr = "abc\\b";

        //和\\b 的含义刚刚相反
        String regStr ="abc\\B";

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 分组

捕获分组

package com.ep.regexp;


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

/***
 * @author dep
 * @version 1.0
 * 捕获分组
 */
public class RegExp05 {
    public static void main(String[] args) {
        String content = "abcd99996665ds45656sd4565s5";

        //下面就是非命名分组
        // 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"));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

非捕获分组

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 非捕获分组,不能通过matcher.group(1)来获取，因为是非捕获分组
 */
public class RegExp06 {
    public static void main(String[] args) {
        String content = "hello 张三教育 jack 张三老师 张三同学 hello 张三学生";
        // 找到 张三教育 、张三老师、张三同学 子字符串
        // String regStr = "张三教育|张三老师|张三同学";
        // 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));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 非贪婪匹配

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 非贪婪匹配
 */
public class RegExp07 {
    public static void main(String[] args) {
        String content ="abc111111";
        //String regStr = "\\d+"; // 默认是贪婪匹配，会匹配到111111
        String regStr = "\\d+?"; // 非贪婪匹配
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 应用实例

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 正则表达式应用实例
 */
public class RegExp08 {
    public static void main(String[] args) {
        String content = "https://www.bilibili.com/account/history?spm_id_from=333.1007.0.0";
        // 汉字
        // String regStr = "^[\\u0391-\\uffe5]+$";

        // 邮政编码 // 要求：1.是 1-9 开头的一个六位数. 比如：123890 // 2. // 3.
        // String regStr = "^[1-9]\\d{5}$";

        // QQ 号码 // 要求: 是 1-9 开头的一个(5 位数-10 位数) 比如: 12389 , 1345687 , 187698765
        //String regStr = "^[1-9]\\d{4,9}$";

        // 手机号码 // 要求: 必须以 13,14,15,18 开头的 11 位数 , 比如 13588889999
        // String regStr = "^1[?:3|4|5|8]\\d{9}$";

        // 网址
        //1. 先确定 url 的开始部分 https:// |http://
       // 2.然后通过 ([\w-]+\.)+[\w-]+ 匹配 www.bilibili.com
        // 3. /video/BV1fh411y7R8?from=sear 匹配(\/[\w-?=&/%.#]*)?
        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("不满足格式");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 正则表达式三个常用类

# pattern类

image-20220913233752036`

package com.ep.regexp;

import java.util.regex.Pattern;

/***
 * @author dep
 * @version 1.0
 * 演示 matches 方法，用于整体匹配, 在验证输入的字符串是否满足条件使用
 */
public class PatternMethod {
    public static void main(String[] args) {

        String content = "hello abc hello,";
        String regStr = "hello.*";
        boolean matches = Pattern.matches(regStr, content);
        if (matches) {
            System.out.println("整体匹配成功");
        } else {
            System.out.println("匹配不成功");
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Matcher类

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * Matcher 类的常用方法
 */
public class MatcherMethod {
    public static void main(String[] args) {
        String content = "hello edu jack edutom hello smith hello";
        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 有 hello 替换成 你好
        String newContent = matcher.replaceAll("你好");
        //注意：返回的字符串才是替换后的字符串 原来的 content 不变化
        System.out.println(newContent);

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 反向引用

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 反向引用
 */
public class RegExp09 {
    public static void main(String[] args) {
        // String content = "abc1122333444555asd4545455555sdad6699dsd2332";
        String content = "12321-333999111";
        // 匹配两个连续的相同数字  (\\d)\\1
        // String regStr = "(\\d)\\1";

        //  匹配5个连续的相同数字  (\\d)\\1{4}
       //  String regStr = "(\\d)\\1{4}";
        // 匹配个位与千位相同，十位与百位相同  (\\d)(\\d)\\2\\1
        // String regStr = "(\\d)(\\d)\\2\\1";

        //请在字符串中检索商品编号.形式如:12321-333999111这样的号码,
        // 要求满足前面是一个五位数,然后一个-号,然后是一个九位数,连续的每三位要相同
         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));
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package com.ep.regexp;

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

/***
 * @author dep
 * @version 1.0
 * 外部反向引用
 */
public class RegExp10 {
    public static void main(String[] args) {
        String content = "我....我要....学学学学....编程 java!";

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

        //2. 去掉重复的字 我我要学学学学编程 java!
        // 思路
        // (1) 使用 (.)\\1+
        // (2) 使用 反向引用$1 来替换匹配到的内容
        // 注意：因为正则表达式变化，所以需要重置 matcher
        Pattern pattern1 = Pattern.compile("(.)\\1+"); //分组的捕获内容记录到$1
        content = pattern1.matcher(content).replaceAll("$1"); //使用 反向引用$1 来替换匹配到的内容
        System.out.println(content);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# String 类中使用正则表达式

替换功能

String 类 public String replaceAll(String regex,String replacement)

判断功能

String 类 public boolean matches(String regex){} **//**使用 Pattern 和 Matcher 类

分割功能

String 类 public String[] split(String regex)

package com.ep.regexp;

/***
 * @author dep
 * @version 1.0
 * String 类中使用正则表达式
 */
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 发布。" +
                "自此 Java 的计算能力有了大幅提升";
        //使用正则表达式方式，将 JDK1.3 和 JDK1.4 替换成 JDK
        String newContent = content.replaceAll("JDK1.3|JDK1.4", "JDK");
        System.out.println(newContent);

        //要求 验证一个 手机号， 要求必须是以 138 139 开头的
        String content1 = "13888889999";
        boolean matches = content1.matches("1(38|39)\\d{8}");
        if (matches) {
            System.out.println("格式正确");
        }else {
            System.out.println("格式不正确");
        }

        //要求按照 # 或者 - 或者 ~ 或者 数字 来分割
        content = "hello#abc-jack12smith~北京";
        String[] split = content.split("#|-|~|\\d+");
        for (String str : split) {
            System.out.println(str);
        }


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# 补充

# 一、校验数字的表达式

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

编辑

#正则表达式

上次更新: 2024/12/19, 09:15:30

← 网络爬虫