正则表达式

Posted on

正则表达式

正则表达式：

正则表达式(Regular Expression)本身也是一个字符串，是==由普通字 符及元字符组成==的模式字符串，它用来==定义别的字符串的组成规则==。

String类中的 boolean matches(String regex)方法可以用来判断当前字符串是否和参数regex指定的正则表达式匹配。

  • 元字符：

    1. ==. 匹配任意单个字符==

    2. ==[] 用来给出取值集合，匹配其中某一个字符==

      ​ 【示例】te[sx]t

    3. 在[]中使用-表示范围，如 [0-9] [A-Za-z0-9]等

    4. ()用来界定子表达式，匹配其中的有序序列

    5. 元字符|表示或的关系

    6. 元字符{n}表示前面的元素的重复n次；{2,5}表示前面的元素重复2到5次； {3,}表示至少重复3次

    7. 对于重复次数的限制，还可使用下列特殊元字符： ==* 表示前面的元素重复0次或多次== ==? 表示前面的元素重复0次或1次== ==+ 表示前面的元素重复1次或多次==

    8. 转义字符\

    9. 元字符^和$， ==^代表字符串开始==，==$代表字符串结束==

    10. 在==[]中使用^表示非==。模式字符串是‘B【^lmn 】’，则表示B后跟的字符不能是l,m,n三者之一。

    11. 其它简洁符号 ==\d == [0-9]== ==\D == 【^0-9】== ==\w == 字母数字下划线== ==\W == 非字母数字下划线== ==\s 所有的空白字符== ==\S非空白字符==

判断正则表达式规则是否符合

  • Pattern 类：

    pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

  • Matcher 类：

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

  • PatternSyntaxException：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//方法一：

//字符串
String s = "a";
//正则表达式规则
String pat = "\\w";
Pattern pattern = Pattern.compile(pat);
Matcher matcher = pattern.matcher(s);
matcher.matches();

//方法二：

String s = "a";
String regex = "\\w";
s.matches(regex);
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @ClassName Demo01
 * @Description 正则表达式
 * @Author renhongchang
 * @Date 2021/7/19 9:22
 * @Version 1.0
 * @Blog https://rhc-rgb.github.io
 *
 */
public class Demo01 {
    public static void main(String[] args) {
        /**
         * \d == [0~9] \d == [^0~9]
         */
        test01();


        /**
         * \w 匹配任意字母、数字、数字、下划线
         * \W 和\w 相反，匹配任意字母、数字、下划线以外的字符
         */
        test02();


        /**
         * \s 匹配所有空白字符   \S 匹配所有非空白字符
         */
        test03();


        /**
         *  [a-z] 匹配[a-z];  [A-Z]匹配[A-Z]
         */
        test04();


        /**
         * find() 方法：查找字符串中是否有符合正则表达式规则的字符串
         * group() 方法：提取符合正则表达式规则的字符串
         */

        /**
         * 匹配提取字符串中的电话号码
         */
        test05();

        /**
         * 提取多个电话号码
         */
        test06();


    }

    private static void test06() {
        String stu = "姓名：张三，手机号码：13956484587，15896547895，13745869587";
        //手机号规则
        String pat = "1\\d{10}";
        //提取电话
        Pattern pattern = Pattern.compile(pat);
        Matcher matcher = pattern.matcher(stu);

        System.out.println(); //换行
        //如果有符合规则的表达式循环执行
        while(matcher.find()){
            //提取符合规则的表达式
            System.out.println(matcher.group());
        }
    }

    private static void test05() {
        String stu = "191203,张三,20,男,15188569453,dhdhdhdhkkf@163.com";

        //电话正则表达式
        String patPhone = "1\\d{10}";
        //邮箱正则表达式
        String patEmail = "\\w+@163.com";

        //提取电话
        Pattern pattern = Pattern.compile(patPhone);
        Matcher matcher = pattern.matcher(stu);

        System.out.println(matcher.find());
        System.out.println(matcher.group());

        //提取邮箱
        Pattern pattern2 = Pattern.compile(patEmail);
        Matcher matcher2 = pattern2.matcher(stu);

        System.out.println(matcher2.find());
        System.out.println(matcher2.group());
    }

    private static void test04() {
        String str1 = "A";
        String str2 = "a";

        String pat1 = "[a-z]";
        String pat2 = "[A-Z]";

        Pattern pattern1 = Pattern.compile(pat1);
        Pattern pattern2 = Pattern.compile(pat2);

        Matcher matcher1 = pattern1.matcher(str1);
        Matcher matcher2 = pattern1.matcher(str2);
        Matcher matcher3 = pattern2.matcher(str1);
        Matcher matcher4 = pattern2.matcher(str2);

        System.out.println(matcher1.matches()?"A是[a-z]":"A不是[a-z]");
        System.out.println(matcher2.matches()?"a是[a-z]":"a不是[a-z]");
        System.out.println(matcher3.matches()?"A是[A-Z]":"A不是[A-Z]");
        System.out.println(matcher4.matches()?"a是[A-Z]":"a不是[A-Z]");
    }

    private static void test03() {
        String s = " ";

        String pat = "\\s";

        Pattern pattern = Pattern.compile(pat);

        Matcher matcher = pattern.matcher(s);

        System.out.println(matcher.matches());
    }


    private static void test01() {
        String s = "15891771111";

        String pat = "1\\d{18}"; //正则表达式规则，1开头 18位数字；

        Pattern pattern = Pattern.compile(pat);  //获取Pattern对象，传入正则表达式

        Matcher matcher = pattern.matcher(s); //创建Matcher传入字符串

        System.out.println(matcher.matches());  //判断字符串是否符合正则表达式规则
    }

    private static void test02() {
        String s = "a";

        String pat = "\\w";
        Pattern pattern = Pattern.compile(pat);
        Matcher matcher = pattern.matcher(s);

        System.out.println(matcher.matches());
    }
}
练习：判断输入手机号码是否正确
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
private static void text01() {
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);

        //设置标记，如果输入错误循环，输入正确就退出循环
        boolean isflag = true;

        while(isflag){
            System.out.println("请输入手机号码：");
            //创建字符串接受键盘输入的手机号码
            String phone = scanner.nextLine();

            //创建手机号码正则表达式规则
            String pat = "(13[0-9]|15[012356789]|18[056789])\\d{8}";

            //判断手机号码是否正确
            if (phone.matches(pat)){
                System.out.println("号码是：");
                System.out.println(phone);
                isflag = false;
            }else{
                System.out.println("输入格式错误，请重新输入！！！");
            }
        }
    }