java学习笔记（二十七）- 正则表达式

一、基本介绍

  • 对字符串执行模式匹配的技术
  • 全称 regular expression -> RegExp

二、元字符

1. 转义符

1
2
\\转义符
需要用到转义符号的字符有：. * + () $ /\ ? [] ^ {}
字符 说明
\ 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n"匹配字符"n”。“\n"匹配换行符。序列”\\\“匹配”\“，”\(“匹配”("。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class RegExp02 {
    public static void main(String[] args) {

        String content = "12&(.adb5";

        //String reg = "\\(";
        String reg = "\\.";

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

2. 字符匹配符

2.1 匹配不区分大小写

1
2
3
4
5
6
//(?i)abc表示abc都不区分大小写a // i表示大小写不敏感
//(?i)bc表示bc不区分大小写
//a((?i)b)c表示只有b不区分大小写

//指定 Pattern.CASE_INSENSITIVE 表示匹配是不区分字母大小写
Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);

2.2 字符匹配符列表

符号 含义 示例 说明
[ ] 可接收的字符列表 [efgh] e、f、g、h中的任意字符
[^] 不可接收字符列表 [^abc] 除a、b、c之外的任意字符，包括数字和特殊符号
- 连字符 A-Z 任意单个大写字母
. 匹配除\n以外的任何字符 a…b 以a开头，b结尾，中间包括2个任意字符的长度为4的字符串
\d 匹配单个数字字符，相当于[0-9] \d{3}{\d}? 包含3个或4个数字的字符串
\D 匹配单个非数字字符，相当于[ ^0-9 ] \D(\d)* 以单个非数字字符开头，后接人一个数字字符串
\w 匹配单个数字、大小写字母符，相当于[0-9a-zA-z] \d{3}\w{4} 以3个数字字符开头的长度为7的数字字母字符串
\W 匹配单个非数字、大小写字母符，相当于[ ^0-9a-zA-z] \W+\d{2} 以至少1个非数字字母符开头，2个数字字符结尾的字符串
\s 匹配任意空白字符，包括空格、制表符、换页符等，相当于[\f\n\r\t\v]
\S 匹配任何非空白字符，相当于[ ^\f\n\r\t\v]
\f 换页匹配符，等效于\x0c 和 \cL
\n 换行匹配符，等效于\x0a 和 \cJ
\r 匹配一个回车符，等效于\x0d 和 \cM
\t 制表匹配符，等效于\x09 和 \cl
\v 垂直制表符匹配，等效于 
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
public class RegTheory {
    public static void main(String[] args) {

        String content = "1998年12月8日，第二代Java平台发布，1999年6月，Sun公司发布了第二代12345678";

        //匹配文中的所有四个数字

        //1. \\d表示一个数字
        //String regStr = "\\d\\d\\d\\d";
        String regStr = "(\\d\\d)(\\d\\d)";//() 表示分组
        //2. 创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        Matcher matcher = pattern.matcher(content);

        //4. 开始匹配
        /**
         * matcher.find() 完成任务 (考虑分组)
         * (\d\d)(\d\d) 正则表达式中有() 表示分组, 第1个() 表示第1组, 第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[3] = 2 groups[4] = 4
         *    2.4 多组以此类推...
         */

        while(matcher.find()) {
            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));//报错 数组下标越界
        }
    }
}
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

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

        String content = "a11c8ab@cABC_ ";
        //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 = "[^a-z]";//匹配 不在 a-z 间的任意字符
        //String regStr = "[^0-9]";//匹配 不在 0-9 间的任意字符
        //String regStr = "[abcd]";//匹配 abcd 间的任意字符
        //String regStr = "[^abcd]";//匹配 不是 abcd 间的任意字符
        //String regStr = "\\d";//匹配 0-9间的任意一个数字
        //String regStr = "\\D";//匹配 不是0-9中的任意一个数字
        //String regStr = "\\w";//匹配 任意英文字符、数字和下划线
        //String regStr = "\\W";//匹配 与\w相反
        //String regStr = "\\s";//匹配 任何空白字符(空格 制表符)
        //String regStr = "\\S";//匹配 与\s相反
        String regStr = "\\.";//匹配 除\n之外的所有字符

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

3. 选择匹配符

  • 在匹配某个字符串的时候是选择性的
符号 含义 示例 说明
| 匹配"|"之前或之后的表达式 ab|cd ab或cd 
1
2
3
4
5
6
7
8
9
10
11
12
public class RegExp04 {
    public static void main(String[] args) {
        String content = "zhibi 执笔 值";
        String regStr = "zhi|执|值";
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);
        Matcher matcher = pattern.matcher(content);

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

4. 限定符

  • 用于指定前面的字符和组合项连续出现的次数
符号 含义 示例 说明 匹配输入
* 指定字符重复0次或n次（无要求） (abc)* 仅包含任意个abc的字符串，等效于\w* abc、abcabcabc
+ 指定字符重复1次或n次（至少一次） m+(abc)* 至少以1个m开头，后接任意个abc的字符串 m、mabc、mabcabc
？ 指定字符重复0次或1次（至多一次） m+abc? 至少以1个m开头，后接ab货abc的字符串 mab、mabc
{n} 只能输入n个字符 [abcd]{3} 由abcd中字母组成的任意长度为3的字符串 abc、acd、adc
{n,} 指定至少n个匹配 [abcd]{3,} 由abcd中字母组成的任意长度不小于3的字符串 aab、dbc、aaabcd
{n,m} 指定至少n个但不多于m个匹配 [abcd]{3,5} 由abcd中字母组成的任意长度不小于3，不大于5的字符串 abc、abcd、aaaaa、bcdaa 
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
public class RegExp05 {
    public static void main(String[] args) {
        //java匹配机制为贪婪匹配, 即尽可能的匹配多的
        //1. {n} 如：a{3} 1{4} (\\d){2}
        String content = "111111aaaahello";
        //String regStr = "a{3}";//匹配aaa
        //String regStr = "1{4}";//匹配1111
        //String regStr = "(\\d){2}";//匹配任意两个数字

        //2. {n,m} 匹配至少出现n次, 最多出现m次 如a{3,4}, 1{4,5},\\d{2,5}
        //String regStr = "a{3,4}";//匹配aaaa 或者aaa 遵守贪婪匹配 即优先匹配aaaa
        //String regStr = "1{4,5}";//匹配1111 或者11111 遵守贪婪匹配 即优先匹配11111
        //String regStr = "\\d{2,5}";//匹配任意2-5位间的数字 遵守贪婪匹配 即优先匹配5位数字

        //3. + 表示出现1次到任意多次 如 a+ 1+ \\d+
        //String regStr = "a+";
        //String regStr = "1+";
        //String regStr = "\\d+";

        //4. * 表示出现0次到任意多次 如a* 1* \\d*
        //String regStr = "a1*";
        //String regStr = "1*";
        //String regStr = "\\d1*";

        //5. ? 表示出现0次到1次 如 a? 1? \\d?
        //String regStr = "a?";
        //String regStr = "1?";
        //String regStr = "\\d1?";
        String regStr = "a2111?";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        int i = 0;
        while(matcher.find()) {
            System.out.println("找到第" + (++i) + "个：" + matcher.group(0));
        }
    }
}

5. 定位符

  • 规定要匹配的字符串出现的位置
符号 含义 示例 说明 匹配输入
^ 指定起始字符 [1]+[a-z]* 以至少1个数字开头，后接任意个小写字母的字符串 123、6aa、555abc
$ 指定结束字符 [2]\-[a-z]+$ 以1个数字开头后接连字符"-"至少1个小写字母结尾的字符串 1-a
\b 匹配目标字符串的边界 zb\b 这里说的字符串的边界指的是子串间有空格，或者是目标字符串的结束位置 lazb nhzb
\B 匹配目标字符串的非边界 zb\B 和\b的含义刚刚相反 zbhh 
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
public class RegExp06 {
    public static void main(String[] args) {

        String content = "c123-ab";
        //1. ^ 指定起始字符
        // ^[0-9]+[a-z]* 指定以至少1个数字开头, 后接任意字母结尾
        //String regStr = "^[0-9]+[a-z]*";

        //2. $ 指定结束字符
        // ^[0-9]+[a-z]+$ 值以至少1个数字开头, 以至少1个任意字母结尾
        //String regStr = "^[0-9]+[a-z]+$";
        // ^[0-9]\\-[a-z]+$ 值以至少1个数字开头,中间是-号 以至少1个任意字母结尾
        //String regStr = "^[0-9]+\\-[a-z]+$";

        //3. \\b 匹配目标字符串的边界[即字符串的结束位置，或者空格前的结束位置]
        //String regStr = "c\\b";
        //4. \\B 与\\b含义相反
        String regStr = "c\\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
33
34
35
public class RegTheory {
    public static void main(String[] args) {

        String content = "1998年12月8日，第二代Java平台发布，1999年6月，Sun公司发布了第二代12345678";

        //匹配文中的所有四个数字

        //1. \\d表示一个数字
        //String regStr = "\\d\\d\\d\\d";
        String regStr = "(\\d\\d)(\\d\\d)";//() 表示分组
        //2. 创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        Matcher matcher = pattern.matcher(content);

        //4. 开始匹配
        /**
         * matcher.find() 完成任务 (考虑分组)
         * (\d\d)(\d\d) 正则表达式中有() 表示分组, 第1个() 表示第1组, 第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[3] = 2 groups[4] = 4
         *    2.4 多组以此类推...
         */

        while(matcher.find()) {
            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));//报错 数组下标越界
        }
    }
}

四、捕获

  • 把正则表达式中的表达式或分组匹配的内容，保存到内存中以数字编号或显示命名的组里，从左向右，以分组的左括号作为标志，第一个出现的分组的组号为1，第二个为2，以此类推；组0表示整个正则表达式

1. 非命名捕获

常用分组构造形式 说明
(pattern) 非命名捕获。捕获匹配的字符串。编号为零的第一个捕获是由整个正则表达式模式匹配的文本，其它捕获结果则根据左括号的顺序从1开始自动编号。
(?:pattern) 匹配pattern但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符(|)组合模式部件的情况很有用。例如，l(?:y|e)是比"ly|le"更好的表达式
(?=pattern) 它是一个非捕获匹配。例如,“Windows (?=95|98|NT|2000)” 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"windows" 相当于取括号内的匹配
(?!pattern) 该表达式匹配不处于匹配pattern的字符串的起始点的搜索字符串。它是一个非捕获匹配。例如，“Windows (?!95|98|NT|2000)“匹配"Windows 3.1"中的"windows”，但是不匹配"Windows 2000"中的"Windows” 相当于排除括号内的匹配 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class RegExp08 {
    public static void main(String[] args) {

        String content = "执笔hello执笔同学执笔你好执笔画江山";

        //1. 找到执笔同学、执笔画江山、执笔你好
        //String regStr = "执笔同学|执笔画江山|执笔你好";//选择匹配符
        // 等价于 非捕获分组 注意：这里不能使用 matcher.group(1)进行输出
        //String regStr = "执笔(?:同学|画江山|你好)";

        //2. 找到执笔关键字但是只要求查找执笔同学 执笔画江山中的执笔
        //String regStr = "执笔(?=同学|画江山)";

        //3. 找到执笔关键字 但是不是执笔同学 执笔画江山中的执笔
        String regStr = "执笔(?!同学|画江山|你好)";

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

2. 命名捕获

常用分组构造形式 说明
(?pattern) 命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中。用于name的字符串不能包含任何标点符号，并且不能以数字开头。可以使用单引号替代尖括号，例如(?‘name’) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class RegExp07 {
    public static void main(String[] args) {

        String content = "he1123l1569lo";
        //1. 非命名捕获分组
        //String regStr = "(\\d\\d)(\\d\\d)";

        //2. 命名捕获分组
        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
public class RegExp13 {
    public static void main(String[] args) {

        String content = "我....我要.....学学学学.....编程java";
        //1. 去除.
        String regStr = "(\\.)\\1+";
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        content = matcher.replaceAll("");
        System.out.println(content);

        //2. 将相同的字替换
//        regStr = "(.)\\1+";
//        pattern = Pattern.compile(regStr);
//        matcher = pattern.matcher(content);
//        while(matcher.find()) {
//            System.out.println("扎到：" + matcher.group(0));
//        }
//        content = matcher.replaceAll("$1");
//        System.out.println(content);

        //3. 简化表示
        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
        System.out.println(content);
    }
}

六、匹配方式

1. 贪婪匹配

  • 默认是贪婪匹配

2. 非贪婪匹配

  • 在匹配符后加 ?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class RegExp09 {
    public static void main(String[] args) {

        String content = "1111abc";
        //String regStr = "\\d+";//默认是贪婪匹配 输出1111
        String regStr = "\\d+?";//非贪婪匹配在匹配符后加 ？

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

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

七、pattern类

  • pattern对象是一个正则表达式对象

  • pattern类没有公共构造方法，要创建一个pattern对象，调用其公共静态方法，返回一个pattern对象，该方法接受一个正则表达式作为它的第一个参数

    1
    Pattern pattern = new Pattern(regStr);//regStr 正则表达式字符串

1. matches方法

1
2
3
4
5
6
7
8
public class Matches_ {
    public static void main(String[] args) {
        String content = "i am study java";
        String regStr = ".*java.*";
        boolean isMatches = Pattern.matches(regStr, content);
        System.out.println("是否整体匹配成功：" + isMatches);
    }
}

八、Matcher类

1. 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
(1) public int start()//返回以前匹配的初始索引。
(2) public int start(int group)//返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
(3) public int end()//返回最后匹配字符之后的偏移量。
(4) public int end(int group)//返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏量
(5) public boolean lookingAt()//尝试将从区域开头开始的输入序列与该模式匹配
(6) public boolean find()//尝试查找与该模式匹配的输入序列的下一个子序列。
(7) //重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
    public boolean find(int start)//
(8) public boolean matches()//尝试将整个区域与模式匹配。

(9) //实现终端添加和替换步骤。
    public Matcher appendReplacement(StringBuffer sb, String replacement)
(10) public StringBuffer appendTail(StringBuffer sb)//实现终端添加和替换步骤。
(11) //替换模式与给定替换字符串相匹配的输入序列的每个子序列。
     public String replaceAll(String replacement)
(12) //替换模式与给定替换字符串匹配的输入序列的第一个子序列。
     public String replaceFirst(String replacement)
(13) //返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement方法一个字面字符串一样工作。   
     public static String quoteReplacement(String s)
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
public class MatcherMethod {
    public static void main(String[] args) {

        String content = "hellozb 123zb hello0zb hello zb";
        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 有zb 替换成执笔
        regStr = "zb";
        pattern = Pattern.compile(regStr);
        matcher = pattern.matcher(content);
        //返回的字符串才是替换后的字符串 原来的content不变化
        String newContent = matcher.replaceAll("执笔");
        System.out.println("newContent= " + newContent);
        System.out.println("content= " + content);
    }
}

九、String类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class StringReg {
    public static void main(String[] args) {

        String content = "2000年5月，JDK1.3、JDK1.4 相继发布....";
        //1. 将JDK1.3、JDK1.4 替换成 JDK
        content = content.replaceAll("JDK1\\.3|JDK1\\.4","JDK");
        System.out.println(content);

        //2. 验证手机号必须是 138 139开头
        content = "13988888888";
        if(content.matches("1(38|39)\\d{8}")) {
            System.out.println("验证成功...");
        } else {
            System.out.println("验证失败...");
        }

        //3. 分割 按照 # 或者 - 或者~ 或者数字进行分割
        content = "hello#abc-tom12jack~china";
        String[] split = content.split("#|-|~|\\d");
        for (String s : split) {
            System.out.println(s);
        }
    }
}

十、案例

1. 解析URL
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
public class Homework03 {
    public static void main(String[] args) {

        /**
         * 3.对一个url进行解析 http://www.sohu.com:8080/abc/index.htm
         * a)要求得到协议是什么?   http
         * b)域名是什么?         www.sohu.com
         * c)端口是健么?         8080
         * d)文件名是什么?       index.htm
         */

        String content = "http://www.sohu.com:8080/abc/index.htm";
        String regStr = "^([a-zA-Z]+)://([a-zA-Z.]+):(\\d+)[\\w/]*/([\\w.]+)";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        if (matcher.matches()) {//整体匹配 如果匹配成功 可以通过group(x), 获取对应分组的内容
            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("匹配失败...");
        }
    }
}
2. 匹配
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Homework02 {
    public static void main(String[] args) {
        /**
         * 2.要求验证是不是整数或者小数
         *   提示:这个题要考虑正数和负数
         *   比如:123 -345 34.89 -87.9 -0.01 0.45等
         */
        String content = "0.89";
        String regStr = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";
        Matcher matcher = Pattern.compile(regStr).matcher(content);

        if(content.matches(regStr)) {
            System.out.println("匹配成功...");
        } else {
            System.out.println("匹配失败...");
        }
    }
}
3. 验证邮箱
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
public class Homework01 {
    public static void main(String[] args) {
        /**
         * 规定电子邮件规则为
         * 1．只能有一个@
         * 2. @前面是用户名,可以是a-z A-Z0-9_-字符
         * 3. @后面是域名,并且域名只能是英文字母，比如sohu.com或者tsinghua.org.cn
         * 4、写出对应的正则表达式,验证输入的字符串是否为满足规则
         */

        String content = "123@shouhu.com";
        String regStr = "^[\\w-]+@([a-zA-Z]+\\.)+[a-zA-Z]+$";
//        Pattern pattern = Pattern.compile(regStr);
//        Matcher matcher = pattern.matcher(content);
//        if (matcher.find()){
//            System.out.println("邮箱满足规则...");
//        } else {
//            System.out.println("邮箱不满足规则...");
//        }
        //1. String 的matchers 是整体匹配

        if (content.matches(regStr)) {
            System.out.println("邮箱满足规则...");
        } else {
            System.out.println("邮箱不满足规则...");
        }
    }
}

  1. 0-9 ↩︎

  2. 0-9 ↩︎