Java正则表达式详解万字笔记内容丰富

正则表达式

1.1 正则表达式的概念及演示

在Java中，我们经常需要验证一些字符串，例如：年龄必须是2位的数字、用户名必须是8位长度而且只能包含大小写字母、数字等。正则表达式就是用来验证各种字符串的规则。它内部描述了一些规则，我们可以验证用户输入的字符串是否符合这些规则。

示例：QQ号码验证

先看一个不使用正则表达式的例子：验证QQ号码是否符合以下规则：

• QQ号码必须是5-15位长度。
• 必须全部是数字。
• 首位不能为0。

package com.rckivy.demo;public class RegexDemo1 {public static void main(String[] args) {String qq = "1234567890";System.out.println(checkQQ(qq));// 使用正则表达式简化验证System.out.println(qq.matches("[1-9]\\d{4,14}"));}// 自定义验证QQ号的方法，不使用正则表达式public static boolean checkQQ(String qq) {int len = qq.length();if (len < 5 || len > 15) { return false;}if (qq.startsWith("0")) { return false;}for (int i = 0; i < len; i++) {char c = qq.charAt(i);if (c < '0' || c > '9') {return false;}}return true;}
}

使用正则表达式简化验证：

public class RegexDemo {public static void main(String[] args) {String qq = "1234567890";System.out.println(qq.matches("[1-9]\\d{4,14}"));}
}

这里的正则表达式 [1-9]\\d{4,14} 表示：

• [1-9]：首位不能为0，只能是1-9。
• \\d{4,14}：接下来4到14位必须是数字，总长度为5到15位。

---

1.2 正则表达式 - 字符类

正则表达式中，可以使用字符类来定义匹配规则，常见的字符类包括：

1. [abc]：表示a、b、c中任意一个字符。
2. [^abc]：表示除a、b、c以外的任意字符。
3. [a-z]：表示a到z的所有小写字母。
4. [A-Z]：表示A到Z的所有大写字母。
5. [0-9]：表示0到9的数字。
6. [a-zA-Z0-9]：表示a到z、A到Z和0到9的任意一个字符。
7. [a-dm-p]：表示a到d或m到p之间的任意字符。

代码示例：

package com.rckivy.demo;public class RegexDemo2 {public static void main(String[] args) {// 使用字符类匹配System.out.println("a".matches("[abc]")); // trueSystem.out.println("z".matches("[abc]")); // falseSystem.out.println("x".matches("[^abc]")); // true// 匹配字母范围System.out.println("z".matches("[a-zA-Z]")); // trueSystem.out.println("A".matches("[a-zA-Z]")); // trueSystem.out.println("0".matches("[a-zA-Z]")); // false// 匹配多个字符System.out.println("z".matches("[a-zA-Z][a-zA-Z]")); // falseSystem.out.println("ab".matches("[a-zA-Z][a-zA-Z]")); // true}
}

---

1.3 正则表达式 - 逻辑运算符

正则表达式中使用逻辑运算符可以灵活地构造匹配模式：

1. &&：并且，表示组合多个条件。
2. |：或者，表示在多个条件之间选择一个。
3. \：转义字符，用于转义特殊字符。

代码示例：

public class RegexDemo {public static void main(String[] args) {// 逻辑运算符匹配String regex = "[a-z&&[^aeiou]]ad";  // 匹配以小写辅音字符开头，后跟adSystem.out.println("bad".matches(regex)); // trueSystem.out.println("had".matches(regex)); // trueregex = "[a|e|i|o|u]ad";  // 匹配以元音字符开头，后跟adSystem.out.println("oad".matches(regex)); // trueSystem.out.println("had".matches(regex)); // false}
}

---

1.4 正则表达式 - 预定义字符

预定义字符类简化了常见字符组的书写，常见的预定义字符类包括：

1. .：匹配任意字符（除了换行符）。
2. \d：匹配任意数字字符（0-9）。
3. \D：匹配任意非数字字符。
4. \s：匹配空白字符（空格、制表符等）。
5. \S：匹配非空白字符。
6. \w：匹配单词字符（字母、数字、下划线）。
7. \W：匹配非单词字符。

代码示例：

public class RegexDemo {public static void main(String[] args) {// 匹配单个字符System.out.println("a".matches("\\w")); // true, 匹配单词字符System.out.println("你".matches("\\w")); // false, 不是字母或数字System.out.println("3".matches("\\d")); // true, 匹配数字字符System.out.println(" ".matches("\\s")); // true, 匹配空格System.out.println("$".matches("\\W")); // true, 匹配非单词字符}
}

---

1.5 正则表达式 - 数量词

数量词用于指定字符或字符组的重复次数：

1. X?：0次或1次。
2. X*：0次到多次。
3. X+：1次或多次。
4. X{n}：恰好n次。
5. X{n,}：至少n次。
6. X{n,m}：n到m次。

代码示例：

public class RegexDemo {public static void main(String[] args) {// 数量词匹配System.out.println("1234".matches("\\d{4}")); // true, 正好4位数字System.out.println("123".matches("\\d{2,4}")); // true, 2到4位数字System.out.println("a".matches("\\w+")); // true, 至少1个字母System.out.println("".matches("\\w*")); // true, 0个或更多字母}
}

---

1.6 正则表达式练习

需求：

• 请编写正则表达式验证用户输入的手机号码是否符合规则：
  • 手机号码必须是以1开头的11位数字。
  • 验证手机号码示例：13112345678、13712345667。

代码示例：

public class RegexDemo {public static void main(String[] args) {String regex = "1[3-9]\\d{9}"; // 匹配手机号码System.out.println("13112345678".matches(regex)); // trueSystem.out.println("13712345667".matches(regex)); // trueSystem.out.println("13945679027".matches(regex)); // trueSystem.out.println("139456790271".matches(regex)); // false}
}

---

1.7 正则表达式练习2

需求：

1. 验证用户名是否满足要求：

   • 用户名由大小写字母、数字和下划线组成，长度为4-16位。

2. 验证身份证号码：

   • 简单要求：18位，前17位为数字，最后一位可以是数字或大写/小写的x。
   • 复杂要求：严格按照身份证号码的格式进行验证，包括出生日期、地区代码等。

用户名验证

用户名的正则表达式规则：

String regex1 = "\\w{4,16}";  // \w 表示字母、数字或下划线，{4,16} 表示长度为4到16位
System.out.println("zhangsan".matches(regex1));  // true
System.out.println("user1234".matches(regex1));  // true
System.out.println("u".matches(regex1));         // false
System.out.println("$123".matches(regex1));       // false

简单身份证号码验证

身份证号的规则：

• 前17位为数字。
• 最后一位可以是数字，也可以是字母X（不区分大小写）。

String regex2 = "[1-9]\\d{16}[\\dXx]";  // 前17位为数字，最后一位为数字或X
System.out.println("41080119930228457x".matches(regex2));  // true
System.out.println("510801197609022309".matches(regex2));  // true
System.out.println("15040119810705387X".matches(regex2));  // true
System.out.println("12345678901234567X".matches(regex2));  // false (开头不能为0)

复杂身份证号码验证

在更复杂的身份证号码规则中，需要验证更多细节，包括：

• 前6位表示地区代码（不能以0开头）。
• 第7到14位表示出生日期，年份为18、19或20开头，月份为01到12，日期为01到31。
• 最后一位同样可以是数字或字母X。

String regex3 = "[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]";
System.out.println("41080119930228457x".matches(regex3));  // true
System.out.println("510801197609022309".matches(regex3));  // true
System.out.println("15040119810705387X".matches(regex3));  // true
System.out.println("130133197204039024".matches(regex3));  // true

---

1.8 本地数据爬取

Pattern 和 Matcher

在Java中，Pattern类用来表示正则表达式，Matcher类则是正则表达式应用到某个文本后的匹配结果对象。我们可以使用它们从大文本中提取出符合正则表达式的子串。

示例：从文本中爬取特定模式的数据

需求：

有如下文本，请从中爬取所有 JavaXX 的内容（XX代表任意数字）。

public class RegexDemo6 {public static void main(String[] args) {String str = "Java自从95年问世以来，经历了很多版本，" +"目前企业中用的最多的是Java8和Java11，" +"下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";// 1. 创建正则表达式的Pattern对象Pattern p = Pattern.compile("Java\\d{0,2}");// 2. 获取Matcher对象Matcher m = p.matcher(str);// 3. 循环查找匹配的内容while (m.find()) {System.out.println(m.group());}}
}

在上面的示例中，Java\\d{0,2} 匹配以 “Java” 开头，后面跟0到2个数字的字符串。m.find() 方法每次查找下一个符合条件的字符串，直到查找完毕。

---

1.9 网络数据爬取

有时候，我们不仅需要从本地数据中提取信息，还需要从网络上的网页中提取数据。这种场景下，可以通过Java中的 URL 和 URLConnection 来获取网页内容，然后使用正则表达式提取所需的数据。

示例：从网页中爬取身份证号码

需求：

从指定的网页中提取所有的身份证号码。

import java.io.*;
import java.net.*;
import java.util.regex.*;public class RegexDemo7 {public static void main(String[] args) throws IOException {// 创建URL对象，连接到网页URL url = new URL("https://example.com/sample_page.html");URLConnection conn = url.openConnection();// 使用BufferedReader读取网页内容BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));String line;// 创建匹配身份证号的正则表达式String regex = "[1-9]\\d{16}[\\dXx]";Pattern pattern = Pattern.compile(regex);// 逐行读取网页内容，查找匹配项while ((line = br.readLine()) != null) {Matcher matcher = pattern.matcher(line);while (matcher.find()) {System.out.println(matcher.group());}}br.close();}
}

这个程序会从网页中逐行读取内容，并使用正则表达式 [1-9]\\d{16}[\\dXx] 匹配身份证号码。

---

1.10 正则表达式爬取数据练习

需求：

从给定的文本中提取出所有的座机号码、邮箱、手机号和热线电话。

文本内容：

来学校学习Java，手机号:[phone]，或者联系邮箱:[e-mail]，
座机电话:[phone]，邮箱:[e-mail]，
热线电话:400-618-9090，4006189090

代码实现：

public class RegexDemo8 {public static void main(String[] args) {String s = "来学校学习Java，手机号:[phone]，" +"或者联系邮箱:[e-mail]，座机电话:[phone]，" +"邮箱:[e-mail]，热线电话:400-618-9090，4006189090";// 正则表达式String regex = "(1[3-9]\\d{9})" +                 // 手机号"|(\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2})" +  // 邮箱"|(0\\d{2,3}-?[1-9]\\d{4,9})" +   // 座机"|(400-?\\d{3}-?\\d{4})";         // 热线电话Pattern p = Pattern.compile(regex);Matcher m = p.matcher(s);// 逐一查找并输出结果while (m.find()) {System.out.println(m.group());}}
}

---

1.11 按需求爬取特定数据

需求：

给定一段文本，爬取出所有符合条件的Java版本信息。

文本内容：

Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，
因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。

需求1：爬取版本号为 8、11 和 17 的 Java 文本，但只显示 “Java”，不显示版本号。

String regex1 = "((?i)Java)(?=8|11|17)";  // 使用正向肯定预查

需求2：爬取版本号为 8、11 和 17 的 Java 文本，显示完整的 “Java8”、“Java11” 和 “Java17”。

String regex2 = "((?i)Java)(8|11|17)";  // 匹配 Java 后面的版本号

需求3：爬取除版本号为 8、11、17 以外的 Java 文本。

String regex3 = "((?i)Java)(?!8|11|17)";  // 使用负向预查，排除指定的版本号

示例代码：

public class RegexDemo9 {public static void main(String[] args) { 			String s = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" + "下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";// 示例1：只匹配Java，不显示版本号String regex1 = "((?i)Java)(?=8|11|17)";Pattern p1 = Pattern.compile(regex1);Matcher m1 = p1.matcher(s);while (m1.find()) {System.out.println(m1.group());}// 示例2：显示Java和版本号String regex2 = "((?i)Java)(8|11|17)";Pattern p2 = Pattern.compile(regex2);Matcher m2 = p2.matcher(s);while (m2.find()) {System.out.println(m2.group());}}
}

---

1.12 贪婪匹配和非贪婪匹配

贪婪匹配：

在正则表达式中，默认情况下是贪婪匹配，即在满足匹配规则的情况下，它会尽可能多地匹配字符。

非贪婪匹配：

如果你希望正则表达式尽量少匹配字符，可以使用非贪婪匹配，即在限定范围内，尽量少地匹配字符。

贪婪匹配和非贪婪匹配的区别在于：

• 贪婪匹配：*、+ 等默认是贪婪的，会尽量多匹配。
• 非贪婪匹配：在 *、+ 等后面加 ?，则变为非贪婪匹配。

示例代码：

public class RegexDemo10 {public static void main(String[] args) {// 贪婪匹配：尽可能多地匹配String s1 = "abbbbbbbbbbbbaaaaaaaa";String regex1 = "ab+";Pattern p1 = Pattern.compile(regex1);Matcher m1 = p1.matcher(s1);while (m1.find()) {System.out.println("贪婪匹配：" + m1.group());}// 非贪婪匹配：尽可能少地匹配String regex2 = "ab+?";Pattern p2 = Pattern.compile(regex2);Matcher m2 = p2.matcher(s1);while (m2.find()) {System.out.println("非贪婪匹配：" + m2.group());}}
}

输出结果：

贪婪匹配：abbbbbbbbbbbb
非贪婪匹配：ab

---

1.13 使用正则表达式切割字符串

String的split方法

Java的 String 类提供了一个 split(String regex) 方法，允许根据正则表达式来拆分字符串。通过 split，可以将匹配正则表达式的部分作为分隔符，从而把字符串切割成多个子串。

示例代码：

public class RegexSplitDemo {public static void main(String[] args) {// 示例字符串String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";// 使用正则表达式切割字符串，将所有非中文部分作为分隔符String[] arr = s.split("[\\w&&[^_]]+");// 遍历并打印结果for (String str : arr) {System.out.println(str);}}
}

输出结果：

小诗诗
小丹丹
小惠惠

---

1.14 使用正则表达式替换内容

String的replaceAll方法

Java中的 replaceAll(String regex, String replacement) 方法，可以使用正则表达式找到需要替换的内容，并将其替换为指定的字符串。这个方法会用 replacement 替换所有符合 regex 的匹配项。

示例代码：

public class RegexReplaceDemo {public static void main(String[] args) {// 示例字符串String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";// 使用正则表达式将所有非中文部分替换为"vs"String result = s.replaceAll("[\\w&&[^_]]+", "vs");// 打印替换后的字符串System.out.println(result);}
}

输出结果：

小诗诗vs小丹丹vs小惠惠

---

1.15 正则表达式-分组括号 ( )

分组括号 () 在正则表达式中用于将部分表达式分组，以便后续引用或者进行逻辑处理。常见应用包括：

• 捕获：通过分组匹配特定内容，并通过组号进行提取。
• 反向引用：使用 \1, \2 等引用之前的分组。
• 非捕获分组：使用 (?:...) 来仅进行分组而不进行捕获。

示例 1：反向引用

需求：判断一个字符串的开始和结束字符是否一致，只考虑单个字符。

public class RegexDemo {public static void main(String[] args) {// 匹配字符串的开始和结束字符是否一致String regex = "(.).+\\1";  // 捕获第一个字符，并在最后匹配同样的字符System.out.println("a123a".matches(regex));  // trueSystem.out.println("b456b".matches(regex));  // trueSystem.out.println("abcba".matches(regex));  // trueSystem.out.println("abcd".matches(regex));   // false}
}

示例 2：多字符反向引用

需求：判断字符串的开始和结束部分是否一致，并且允许多个字符。

public class RegexDemo {public static void main(String[] args) {// 匹配字符串的开始部分和结束部分是否一致，支持多字符String regex = "(.+).+\\1";  // 捕获开始部分，并在最后匹配相同的内容System.out.println("abc123abc".matches(regex));  // trueSystem.out.println("def456def".matches(regex));  // trueSystem.out.println("xyz789abc".matches(regex));  // false}
}

示例 3：非捕获分组

有时我们只需要分组但不需要捕获内容，这时可以使用非捕获分组 (?:...)。这在提高效率和避免组号混淆时很有用。

public class RegexDemo {public static void main(String[] args) {// 使用非捕获分组，只分组不捕获String regex = "(?:abc)+";  // 匹配 "abc" 一次或多次，不捕获System.out.println("abcabc".matches(regex));  // trueSystem.out.println("abc".matches(regex));     // trueSystem.out.println("abcd".matches(regex));    // false}
}

---

1.16 忽略大小写匹配

在正则表达式中，我们可以使用 (?i) 来忽略大小写匹配。例如，(?i)abc 将匹配 abc、ABC、Abc 等大小写混合的情况。

在正则表达式中，可以使用 (?i) 来忽略大小写的匹配。

示例：

public class RegexDemo {public static void main(String[] args) {// 忽略大小写匹配 "abc"String regex = "(?i)abc";  // 忽略大小写匹配 "abc"System.out.println("abc".matches(regex));  // trueSystem.out.println("ABC".matches(regex));  // trueSystem.out.println("AbC".matches(regex));  // true}
}

局部忽略大小写：

public class RegexDemo {public static void main(String[] args) {// 匹配 "abc"，只忽略中间的 "b" 大小写String regex = "a(?i)bC";  System.out.println("aBc".matches(regex));  // trueSystem.out.println("abc".matches(regex));  // false}
}

---

1.17 非捕获分组

有时候，我们希望将正则表达式的一部分进行分组，但不希望在匹配结果中引用这个分组。我们可以使用非捕获分组 (?:)，这种分组不会占用分组编号。

示例：身份证号验证

需求：验证18位身份证号码，前17位必须为数字，最后一位可以是数字或大小写的 “X”。

public class RegexDemo {public static void main(String[] args) {// 非捕获分组，仅用于分组不捕获String regex = "[1-9]\\d{16}(?:\\d|X|x)";System.out.println("41080119930228457X".matches(regex));  // trueSystem.out.println("510801197609022309".matches(regex));  // trueSystem.out.println("15040119810705387x".matches(regex));  // true}
}

---

gex)); // true
System.out.println(“abc”.matches(regex)); // false
}
}

---## 1.17 非捕获分组有时候，我们希望将正则表达式的一部分进行分组，但不希望在匹配结果中引用这个分组。我们可以使用非捕获分组 `(?:)`，这种分组不会占用分组编号。### 示例：身份证号验证需求：验证18位身份证号码，前17位必须为数字，最后一位可以是数字或大小写的 "X"。```java
public class RegexDemo {public static void main(String[] args) {// 非捕获分组，仅用于分组不捕获String regex = "[1-9]\\d{16}(?:\\d|X|x)";System.out.println("41080119930228457X".matches(regex));  // trueSystem.out.println("510801197609022309".matches(regex));  // trueSystem.out.println("15040119810705387x".matches(regex));  // true}
}

---