释放双眼，带上耳机，听听看~！
正式学习前，先通过一个简单的案例引入：
校验qq号码：
- 1:要求必须是5-15位数字
- 2:0不能开头
分析：
-
键盘录入一个QQ号码
-
写一个功能实现校验
-
调用功能，输出结果
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
2
3import java.util.Scanner;
4
5public class RegexDemo {
6 public static void main(String[] args) {
7 // 创建键盘录入对象
8 Scanner sc = new Scanner(System.in);
9 System.out.println("请输入你的QQ号码：");
10 String qq = sc.nextLine();
11
12 System.out.println("checkQQ:"+checkQQ(qq));
13 }
14
15 /*
16 * 写一个功能实现校验 两个明确： 明确返回值类型：boolean 明确参数列表：String qq
17 */
18 public static boolean checkQQ(String qq) {
19 boolean flag = true;
20
21 // 校验长度
22 if (qq.length() >= 5 && qq.length() <= 15) {
23 // 0不能开头
24 if (!qq.startsWith("0")) {
25 // 必须是数字
26 char[] chs = qq.toCharArray();
27 for (int x = 0; x < chs.length; x++) {
28 char ch = chs[x];
29 if (!Character.isDigit(ch)) {
30 flag = false;
31 break;
32 }
33 }
34 } else {
35 flag = false;
36 }
37 } else {
38 flag = false;
39 }
40
41 return flag;
42 }
43}
44
45
46
没学正则表达式之前，代码这样实现有点麻烦，繁琐。下面通过正则表达式稍微改进代码，如下;
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
2
3import java.util.Scanner;
4
5/*
6 * 正则表达式：符合一定规则的字符串。
7 */
8public class RegexDemo2 {
9 public static void main(String[] args) {
10 // 创建键盘录入对象
11 Scanner sc = new Scanner(System.in);
12 System.out.println("请输入你的QQ号码：");
13 String qq = sc.nextLine();
14
15 System.out.println("checkQQ:" + checkQQ(qq));
16 }
17
18 public static boolean checkQQ(String qq) {
19 // String regex ="[1-9][0-9]{4,14}";
20 // //public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式
21 // boolean flag = qq.matches(regex);
22 // return flag;
23
24 //return qq.matches("[1-9][0-9]{4,14}");
25
26 return qq.matches("[1-9]\\d{4,14}");
27 }
28}
29
以上两个代码的效果是一样的。明显使用正则表达式更简洁些。那什么是正则表达式呢？
1、Java 正则表达式
- 正则表达式定义了字符串的模式。
- 正则表达式可以用来搜索、编辑或处理文本。
- 正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。
java.util.regex 包主要包括以下三个类：
- Pattern 类：
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
- Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
- PatternSyntaxException：
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
可以查看API文档中Pattern类，了解正则表达式规则：
2、正则表达式语法
在其他语言中，\ 表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。
在 Java 中，\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
所以，在其他的语言中（如Perl），一个反斜杠 \ 就足以具有转义的作用，而在 Java 中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在 Java 的正则表达式中，两个 \ 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 \d，而表示一个普通的反斜杠是 \\。
| 字符 | 说明 |
| \ | 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，"n"匹配字符"n"。"\n"匹配换行符。序列"\"匹配""，"("匹配"("。 |
| ^ | 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。 |
| $ | 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。 |
| * | 零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。 |
| + | 一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。 |
| ? | 零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。 |
| {n} | n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。 |
| {n,} | n 是非负整数。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。 |
| {n,m} | M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间。 |
| ? | 当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。 |
| . | 匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。 |
| (pattern) | 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"("或者")"。 |
| (?:pattern) | 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。 |
| (?=pattern) | 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 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"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。 |
| x|y | 匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。 |
| [xyz] | 字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。 |
| [^xyz] | 反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。 |
| [a-z] | 字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。 |
| [^a-z] | 反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。 |
| \b | 匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。 |
| \B | 非字边界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。 |
| \cx | 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。 |
| \d | 数字字符匹配。等效于 [0-9]。 |
| \D | 非数字字符匹配。等效于 [^0-9]。 |
| \f | 换页符匹配。等效于 \x0c 和 \cL。 |
| \n | 换行符匹配。等效于 \x0a 和 \cJ。 |
| \r | 匹配一个回车符。等效于 \x0d 和 \cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。 |
| \S | 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。 |
| \t | 制表符匹配。与 \x09 和 \cI 等效。 |
| \v | 垂直制表符匹配。与 \x0b 和 \cK 等效。 |
| \w | 匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。 |
| \W | 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。 |
| \xn | 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。 |
| \num | 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。 |
| \n | 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。 |
| \nm | 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。 |
| \nml | 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。 |
| \un | 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。 |
1 | 1 |
API中大致如下，由于很多种，都记住的话就有点多。用到时可以再查看API
常用的规则如下：
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
2 x 字符 x。举例：'a'表示字符a
3 \\ 反斜线字符。
4 \n 新行（换行）符 ('\u000A')
5 \r 回车符 ('\u000D')
6
7B:字符类
8 [abc] a、b 或 c（简单类）
9 [^abc] 任何字符，除了 a、b 或 c（否定）
10 [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
11 [0-9] 0到9的字符都包括
12
13C:预定义字符类
14 . 任何字符。我的就是.字符本身，怎么表示呢? \.
15 \d 数字：[0-9]
16 \w 单词字符：[a-zA-Z_0-9]
17 在正则表达式里面组成单词的东西必须有这些东西组成
18
19D:边界匹配器
20 ^ 行的开头
21 $ 行的结尾
22 \b 单词边界
23 就是不是单词字符的地方。
24 举例：hello world?haha;xixi
25
26E:Greedy 数量词
27 X? X，一次或一次也没有
28 X* X，零次或多次
29 X+ X，一次或多次
30 X{n} X，恰好 n 次
31 X{n,} X，至少 n 次
32 X{n,m} X，至少 n 次，但是不超过 m 次
33
3、正则表达式的应用
判断功能
public
boolean
matches(String regex)
分割功能
public String[] split(String regex)
替换功能
public String
replaceAll
(String
regex,String
replacement)
获取功能
Pattern
和
Matcher
类的使用
- **判断功能：
public
boolean
matches(String regex) matches(比赛)**
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
2
3import java.util.Scanner;
4
5/*
6 * 判断功能
7 * String类的public boolean matches(String regex)
8 *
9 * 需求：
10 * 判断手机号码是否满足要求?
11 *
12 * 分析：
13 * A:键盘录入手机号码
14 * B:定义手机号码的规则
15 * 13436975980
16 * 13688886868
17 * 13866668888
18 * 13456789012
19 * 13123456789
20 * 18912345678
21 * 18886867878
22 * 18638833883
23 * C:调用功能，判断即可
24 * D:输出结果
25 */
26public class RegexDemo {
27 public static void main(String[] args) {
28 //键盘录入手机号码
29 Scanner sc = new Scanner(System.in);
30 System.out.println("请输入你的手机号码：");
31 String phone = sc.nextLine();
32
33 //定义手机号码的规则
34 String regex = "1[38]\\d{9}";
35
36 //调用功能，判断即可
37 boolean flag = phone.matches(regex);
38
39 //输出结果
40 System.out.println("flag:"+flag);
41 }
42}
43
44
练习：
校验邮箱
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
2
3import java.util.Scanner;
4
5/*
6 * 校验邮箱
7 *
8 * 分析：
9 * A:键盘录入邮箱
10 * B:定义邮箱的规则
11 * 1517806580@qq.com
12 * wenqing@163.com
13 * xiaoming@126.com
14 * xiaoliang@sina.com.cn
15 * hewen@itcast.cn
16 * C:调用功能，判断即可
17 * D:输出结果
18 */
19public class RegexTest {
20 public static void main(String[] args) {
21 //键盘录入邮箱
22 Scanner sc = new Scanner(System.in);
23 System.out.println("请输入邮箱：");
24 String email = sc.nextLine();
25
26 //定义邮箱的规则
27 //String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";
28 String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";
29
30 //调用功能，判断即可
31 boolean flag = email.matches(regex);
32
33 //输出结果
34 System.out.println("flag:"+flag);
35 }
36}
37
- 分割功能: public String[] split(String regex) split(分割，分裂)
String类的public String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
测试例子：
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
2
3import java.util.Scanner;
4
5/*
6 * 分割功能
7 * String类的public String[] split(String regex)
8 * 根据给定正则表达式的匹配拆分此字符串。
9 *
10 * 范围:"20-24"
11 *
12 * age>=20 && age<=24
13 */
14public class RegexDemo {
15 public static void main(String[] args) {
16 //定义一个年龄搜索范围
17 String ages = "20-24";
18
19 //定义规则(正则)
20 String regex = "-";
21
22 //调用方法（转数组）
23 String[] strArray = ages.split(regex);
24
25// //遍历（测试数组元素，这里只有两个：20、24）
26// for(int x=0; x<strArray.length; x++){
27// System.out.println(strArray[x]);
28// }
29
30 //如何得到int类型的呢?（数组转int类型）
31 int startAge = Integer.parseInt(strArray[0]);
32 int endAge = Integer.parseInt(strArray[1]);
33
34 //键盘录入年龄
35 Scanner sc = new Scanner(System.in);
36 System.out.println("请输入你的年龄：");
37 int age = sc.nextInt();
38
39 if(age>=startAge && age<=endAge) {
40 System.out.println("你就是我想找的");
41 }else {
42 System.out.println("不符合我的要求，gun");
43 }
44 }
45}
46
47
小练习：
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
2
3/*
4 * 分割功能练习
5 */
6public class RegexDemo2 {
7 public static void main(String[] args) {
8 // 定义一个字符串
9 String s1 = "aa,bb,cc";
10 // 直接分割
11 String[] str1Array = s1.split(",");
12 for (int x = 0; x < str1Array.length; x++) {
13 System.out.println(str1Array[x]); //aa bb cc
14 }
15 System.out.println("---------------------");
16
17 String s2 = "aa.bb.cc";
18 String[] str2Array = s2.split("\\."); //注意转义.
19 for (int x = 0; x < str2Array.length; x++) {
20 System.out.println(str2Array[x]); //aa bb cc
21 }
22 System.out.println("---------------------");
23
24 String s3 = "aa bb cc";
25 String[] str3Array = s3.split(" +"); //注意空格
26 for (int x = 0; x < str3Array.length; x++) {
27 System.out.println(str3Array[x]);
28 }
29 System.out.println("---------------------");
30
31 //硬盘上的路径，我们应该用\\替代\
32 String s4 = "E:\\JavaSE\\day14\\avi";
33 String[] str4Array = s4.split("\\\\"); //java中的两个\\相当于其他语言的一个\
34 for (int x = 0; x < str4Array.length; x++) {
35 System.out.println(str4Array[x]);
36 }
37 System.out.println("---------------------");
38 }
39}
40
案例练习：
字符串:"91 27 46 38 50"
请写代码实现最终输出结果是："27 38 46 50 91"
分析：
A:定义一个字符串
B:把字符串进行分割，得到一个字符串数组
C:把字符串数组变换成int数组
D:对int数组排序
E:把排序后的int数组在组装成一个字符串
F:输出字符串
代码实现：
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
2
3import java.util.Arrays;
4
5public class RegexTest {
6 public static void main(String[] args) {
7 // 定义一个字符串
8 String s = "91 27 46 38 50";
9
10 // 把字符串进行分割，得到一个字符串数组
11 String[] strArray = s.split(" ");
12
13 // 把字符串数组变换成int数组
14 int[] arr = new int[strArray.length];
15
16 for (int x = 0; x < arr.length; x++) {
17 arr[x] = Integer.parseInt(strArray[x]);
18 }
19
20 // 对int数组排序
21 Arrays.sort(arr);
22
23 // 把排序后的int数组在组装成一个字符串
24 StringBuilder sb = new StringBuilder();
25 for (int x = 0; x < arr.length; x++) {
26 sb.append(arr[x]).append(" ");
27 }
28 //转化为字符串
29 String result = sb.toString().trim();
30
31 //输出字符串
32 System.out.println("result:"+result);
33 }
34}
35
36
- **替换功能
public String replaceAll
(String
regex,String
replacement) replace(替换)**
代码测试如下：
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
2
3/*
4 * 替换功能
5 * String类的public String replaceAll(String regex,String replacement)
6 * 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
7 */
8public class RegexDemo {
9 public static void main(String[] args) {
10 // 定义一个字符串，正则规则。
11 String s = "helloqq12345worldkh622112345678java";
12
13 // 去除所有的数字,用*给替换掉
14 // String regex = "\\d+"; //多个数字
15 // String regex = "\\d"; //一个数字
16 //String ss = "*";
17
18
19 // 直接把数字去掉
20 String regex = "\\d+";
21 String ss = "";
22
23 //调用方法
24 String result = s.replaceAll(regex, ss);
25 System.out.println(result);
26 }
27}
28
29
-
获取功能
Pattern
和
Matcher
类的使用（重要）
查看API如下：
简单测试模式和匹配器的使用，下面是用两者和使用String类来分别实现判断功能，如下：
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
2
3import java.util.regex.Matcher;
4import java.util.regex.Pattern;
5
6/*
7 * 获取功能
8 * Pattern和Matcher类的使用
9 *
10 * 模式和匹配器的基本使用顺序
11 */
12public class RegexDemo {
13 public static void main(String[] args) {
14 // 模式和匹配器的典型调用顺序
15
16 // 把正则表达式编译成模式对象
17 Pattern p = Pattern.compile("a*b");
18 // 通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串
19 Matcher m = p.matcher("aaaaab");
20 // 调用匹配器对象的功能
21 boolean b = m.matches();
22 System.out.println(b); //true
23
24 //这个是判断功能，但是如果做判断，上面这样做就有点麻烦，我们可以直接用字符串的方法做
25 String s = "aaaaab";
26 String regex = "a*b";
27 boolean bb = s.matches(regex);
28 System.out.println(bb); //true
29 }
30}
31
获取功能的代码测试过程演示如下：
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
2
3import java.util.regex.Matcher;
4import java.util.regex.Pattern;
5
6/*
7 * 获取功能：
8 * 获取下面这个字符串中由三个字符组成的单词
9 * hello xiao ming, ni xin huan java xue xi ma?
10 */
11public class RegexDemo2 {
12 public static void main(String[] args) {
13 // 定义字符串
14 String s = "hello xiao ming, ni xin huan java xue xi ma?";
15 // 规则
16 String regex = "\\b\\w{4}\\b"; //忘记规则，请查看正则规则
17
18 // 把规则编译成模式对象
19 Pattern p = Pattern.compile(regex);
20 // 通过模式对象得到匹配器对象
21 Matcher m = p.matcher(s);
22
23 // 调用匹配器对象的功能
24 // 通过find方法就是查找有没有满足条件的子串
25 // public boolean find()
26 // boolean flag = m.find();
27 // System.out.println(flag); //true
28
29 // // 如何得到值呢?
30 // // public String group()
31 // String ss = m.group();
32 // System.out.println(ss); //xiao
33 //
34 // // 再来一次
35 // flag = m.find();
36 // System.out.println(flag);
37 // ss = m.group();
38 // System.out.println(ss);
39
40 while (m.find()) {
41 System.out.println(m.group());
42 }
43
44 // 注意：一定要先find()，然后才能group()
45 // IllegalStateException: No match found
46 // String ss = m.group();
47 // System.out.println(ss);
48 }
49}
50
51
