正则表达式在Java字符串操作中的全面应用指南从基础语法到高级模式掌握高效处理文本数据的必备技能解决实际开发难题

威震华夏关云长

引言

正则表达式（Regular Expression）是一种强大的文本处理工具，它使用特定的字符序列来描述和匹配字符串模式。在Java开发中，正则表达式是处理文本数据的必备技能，无论是数据验证、信息提取还是文本替换，正则表达式都能提供简洁而高效的解决方案。

随着大数据和文本分析的发展，掌握正则表达式已成为Java开发者的核心竞争力之一。本文将从基础语法开始，逐步深入到高级应用技巧，帮助读者全面掌握正则表达式在Java字符串操作中的应用，解决实际开发中的文本处理难题。

正则表达式基础语法

字符类

字符类是正则表达式中最基本的构建块，用于匹配特定类型的字符。

• 普通字符：大多数字符（如字母、数字）会直接匹配自身。例如，正则表达式"Java"会匹配字符串中的”Java”。
• 简单类：使用方括号[]定义字符集，匹配其中的任意一个字符。例如，[abc]匹配”a”、”b”或”c”。
• 否定类：使用[^]定义否定字符集，匹配不在其中的任意字符。例如，[^abc]匹配除”a”、”b”、”c”外的任意字符。
• 范围类：使用连字符-定义字符范围。例如，[a-z]匹配任意小写字母，[0-9]匹配任意数字。
• 预定义类：一些常用的字符类有简写形式：\d：数字字符，等同于[0-9]\D：非数字字符，等同于[^0-9]\w：单词字符（字母、数字、下划线），等同于[a-zA-Z0-9_]\W：非单词字符，等同于[^a-zA-Z0-9_]\s：空白字符（空格、制表符、换行符等）\S：非空白字符
• \d：数字字符，等同于[0-9]
• \D：非数字字符，等同于[^0-9]
• \w：单词字符（字母、数字、下划线），等同于[a-zA-Z0-9_]
• \W：非单词字符，等同于[^a-zA-Z0-9_]
• \s：空白字符（空格、制表符、换行符等）
• \S：非空白字符

• \d：数字字符，等同于[0-9]
• \D：非数字字符，等同于[^0-9]
• \w：单词字符（字母、数字、下划线），等同于[a-zA-Z0-9_]
• \W：非单词字符，等同于[^a-zA-Z0-9_]
• \s：空白字符（空格、制表符、换行符等）
• \S：非空白字符

2. // 示例：使用字符类匹配
3. String text = "The price is $123.45";
4. // 匹配所有数字
5. Pattern pattern = Pattern.compile("\\d+");
6. Matcher matcher = pattern.matcher(text);
7. while (matcher.find()) {
8.     System.out.println("Found number: " + matcher.group());
9. }
10. // 输出: Found number: 123
11. // 输出: Found number: 45

复制代码

量词

量词用于指定前面的字符或字符组出现的次数。

• *：零次或多次
• +：一次或多次
• ?：零次或一次
• {n}：恰好n次
• {n,}：至少n次
• {n,m}：至少n次，至多m次

2. // 示例：使用量词匹配
3. String text = "a abc abcd abcde";
4. // 匹配以a开头，后面跟着1到3个b的字符串
5. Pattern pattern = Pattern.compile("ab{1,3}");
6. Matcher matcher = pattern.matcher(text);
7. while (matcher.find()) {
8.     System.out.println("Found match: " + matcher.group());
9. }
10. // 输出: Found match: ab
11. // 输出: Found match: abb
12. // 输出: Found match: abbb

复制代码

边界匹配

边界匹配用于指定匹配位置，而不是字符本身。

• ^：行的开始
• $：行的结束
• \b：单词边界
• \B：非单词边界
• \A：输入的开始
• \Z：输入的结束（不包括最后的终止符）
• \z：输入的结束（包括最后的终止符）

2. // 示例：使用边界匹配
3. String text = "Java is a programming language. Java is widely used.";
4. // 匹配句子开头的Java
5. Pattern pattern = Pattern.compile("^Java");
6. Matcher matcher = pattern.matcher(text);
7. if (matcher.find()) {
8.     System.out.println("Found Java at start: " + matcher.group());
9. }
10. // 输出: Found Java at start: Java
12. // 匹配单词边界上的Java
13. pattern = Pattern.compile("\\bJava\\b");
14. matcher = pattern.matcher(text);
15. while (matcher.find()) {
16.     System.out.println("Found Java as whole word: " + matcher.group());
17. }
18. // 输出: Found Java as whole word: Java
19. // 输出: Found Java as whole word: Java

复制代码

分组和捕获

分组使用圆括号()实现，可以将多个字符作为一个单元，并可以捕获匹配的文本。

• (pattern)：捕获组，将匹配的文本捕获起来
• (?:pattern)：非捕获组，不捕获匹配的文本
• (?<name>pattern)：命名捕获组，给捕获组命名
• \n：反向引用，引用第n个捕获组匹配的内容
• \k<name>：命名反向引用，引用指定名称的捕获组

2. // 示例：使用分组和捕获
3. String text = "John Smith, Alice Johnson, Bob Brown";
4. // 匹配名字和姓氏，并捕获
5. Pattern pattern = Pattern.compile("(\\w+)\\s+(\\w+)");
6. Matcher matcher = pattern.matcher(text);
7. while (matcher.find()) {
8.     System.out.println("Full name: " + matcher.group());
9.     System.out.println("First name: " + matcher.group(1));
10.     System.out.println("Last name: " + matcher.group(2));
11. }
12. /*
13. 输出:
14. Full name: John Smith
15. First name: John
16. Last name: Smith
17. Full name: Alice Johnson
18. First name: Alice
19. Last name: Johnson
20. Full name: Bob Brown
21. First name: Bob
22. Last name: Brown
23. */

复制代码

Java中的正则表达式API

Java提供了丰富的API来支持正则表达式操作，主要包括java.util.regex包中的Pattern和Matcher类，以及String类中的便捷方法。

Pattern类

Pattern类表示编译后的正则表达式模式，它是不可变的，可以被多个Matcher实例共享。

• Pattern.compile(String regex)：编译正则表达式，创建Pattern对象
• Pattern.compile(String regex, int flags)：编译正则表达式，并指定匹配标志
• Pattern.matches(String regex, CharSequence input)：快速匹配整个输入序列
• Pattern.quote(String s)：返回指定字符串的字面量模式字符串
• Pattern.split(CharSequence input)：使用模式分割输入序列

常用的匹配标志包括：

• Pattern.CASE_INSENSITIVE：启用不区分大小写的匹配
• Pattern.MULTILINE：启用多行模式，^和$匹配行的开始和结束
• Pattern.DOTALL：启用点全部模式，.匹配包括行结束符在内的所有字符
• Pattern.UNICODE_CASE：启用Unicode感知的大小写折叠
• Pattern.CANON_EQ：启用规范等价

2. // 示例：使用Pattern类
3. String text = "Cat\nDog\nBird\nfish";
5. // 编译不区分大小写的模式
6. Pattern pattern = Pattern.compile("cat", Pattern.CASE_INSENSITIVE);
7. Matcher matcher = pattern.matcher(text);
8. while (matcher.find()) {
9.     System.out.println("Found match: " + matcher.group());
10. }
11. // 输出: Found match: Cat
13. // 使用多行模式匹配行首
14. pattern = Pattern.compile("^[A-Z]", Pattern.MULTILINE);
15. matcher = pattern.matcher(text);
16. while (matcher.find()) {
17.     System.out.println("Found capital at line start: " + matcher.group());
18. }
19. /*
20. 输出:
21. Found capital at line start: C
22. Found capital at line start: D
23. Found capital at line start: B
24. */

复制代码

Matcher类

Matcher类是对输入字符串进行解释和匹配操作的引擎。

• matcher.matches()：尝试将整个区域与模式匹配
• matcher.lookingAt()：尝试从区域开头开始匹配模式
• matcher.find()：尝试查找与模式匹配的输入序列的下一个子序列
• matcher.find(int start)：重置匹配器，然后从指定索引开始尝试查找匹配的子序列
• matcher.group()：返回上一个匹配的结果
• matcher.group(int group)：返回上一个匹配操作中指定组所匹配的输入子序列
• matcher.group(String name)：返回上一个匹配操作中指定命名组所匹配的输入子序列
• matcher.start()：返回上一个匹配的开始索引
• matcher.end()：返回上一个匹配的结束索引
• matcher.replaceAll(String replacement)：将所有匹配的子序列替换为指定的替换字符串
• matcher.replaceFirst(String replacement)：将第一个匹配的子序列替换为指定的替换字符串
• matcher.appendReplacement(StringBuffer sb, String replacement)：实现非终端的添加和替换步骤
• matcher.appendTail(StringBuffer sb)：实现终端的添加和替换步骤

2. // 示例：使用Matcher类
3. String text = "The quick brown fox jumps over the lazy dog.";
4. Pattern pattern = Pattern.compile("\\b\\w{4}\\b"); // 匹配4个字母的单词
5. Matcher matcher = pattern.matcher(text);
7. // 查找所有匹配
8. while (matcher.find()) {
9.     System.out.println("Found 4-letter word: " + matcher.group() +
10.                       " at position " + matcher.start() + "-" + matcher.end());
11. }
12. /*
13. 输出:
14. Found 4-letter word: over at position 26-30
15. Found 4-letter word: lazy at position 35-39
16. */
18. // 替换所有匹配
19. String result = matcher.replaceAll("****");
20. System.out.println("After replacement: " + result);
21. // 输出: After replacement: The quick brown fox jumps **** the **** dog.

复制代码

String类中的正则方法

String类提供了一些便捷方法，可以直接使用正则表达式进行操作。

• String.matches(String regex)：判断字符串是否匹配给定的正则表达式
• String.split(String regex)：根据正则表达式分割字符串
• String.split(String regex, int limit)：根据正则表达式分割字符串，限制分割次数
• String.replaceFirst(String regex, String replacement)：替换第一个匹配的子序列
• String.replaceAll(String regex, String replacement)：替换所有匹配的子序列

2. // 示例：使用String类中的正则方法
3. String text = "apple,banana,orange,grape";
5. // 使用split方法分割字符串
6. String[] fruits = text.split(",");
7. System.out.println("Fruits array: " + Arrays.toString(fruits));
8. // 输出: Fruits array: [apple, banana, orange, grape]
10. // 使用matches方法验证格式
11. String email = "user@example.com";
12. if (email.matches("[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}")) {
13.     System.out.println("Valid email format");
14. } else {
15.     System.out.println("Invalid email format");
16. }
17. // 输出: Valid email format
19. // 使用replaceAll方法替换文本
20. String result = text.replaceAll("[aeiou]", "*");
21. System.out.println("After replacing vowels: " + result);
22. // 输出: After replacing vowels: *ppl*,b*n*n*,*r*ng*,gr*p*

复制代码

常见字符串操作应用

验证

正则表达式常用于验证输入数据是否符合特定格式，如电子邮件、电话号码、日期等。

2. // 示例：电子邮件验证
3. public class EmailValidator {
4.     private static final String EMAIL_REGEX =
5.         "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
6.    
7.     public static boolean isValidEmail(String email) {
8.         if (email == null) {
9.             return false;
10.         }
11.         return email.matches(EMAIL_REGEX);
12.     }
13.    
14.     public static void main(String[] args) {
15.         String[] emails = {
16.             "user@example.com",
17.             "user.name@example.com",
18.             "user-name@example.co.uk",
19.             "user@subdomain.example.com",
20.             "invalid.email",
21.             "@example.com",
22.             "user@.com"
23.         };
24.         
25.         for (String email : emails) {
26.             System.out.println(email + " is " + (isValidEmail(email) ? "valid" : "invalid"));
27.         }
28.     }
29. }
30. /*
31. 输出:
32. user@example.com is valid
33. user.name@example.com is valid
34. user-name@example.co.uk is valid
35. user@subdomain.example.com is valid
36. invalid.email is invalid
37. @example.com is invalid
38. user@.com is invalid
39. */

复制代码

2. // 示例：电话号码验证
3. public class PhoneNumberValidator {
4.     // 支持多种格式：(123) 456-7890, 123-456-7890, 123.456.7890, 1234567890
5.     private static final String PHONE_REGEX =
6.         "^(\\(\\d{3}\\)\\s|\\d{3}[-.]?)?\\d{3}[-.]?\\d{4}$";
7.    
8.     public static boolean isValidPhoneNumber(String phoneNumber) {
9.         if (phoneNumber == null) {
10.             return false;
11.         }
12.         return phoneNumber.matches(PHONE_REGEX);
13.     }
14.    
15.     public static void main(String[] args) {
16.         String[] phoneNumbers = {
17.             "(123) 456-7890",
18.             "123-456-7890",
19.             "123.456.7890",
20.             "1234567890",
21.             "123 456 7890",
22.             "12-345-67890"
23.         };
24.         
25.         for (String phoneNumber : phoneNumbers) {
26.             System.out.println(phoneNumber + " is " +
27.                 (isValidPhoneNumber(phoneNumber) ? "valid" : "invalid"));
28.         }
29.     }
30. }
31. /*
32. 输出:
33. (123) 456-7890 is valid
34. 123-456-7890 is valid
35. 123.456.7890 is valid
36. 1234567890 is valid
37. 123 456 7890 is invalid
38. 12-345-67890 is invalid
39. */

复制代码

查找

正则表达式可以用于在文本中查找符合特定模式的内容。

2. // 示例：查找URL
3. public class URLFinder {
4.     public static void findURLs(String text) {
5.         // 简单的URL正则表达式
6.         String urlRegex = "(https?|ftp|file)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]";
7.         
8.         Pattern pattern = Pattern.compile(urlRegex);
9.         Matcher matcher = pattern.matcher(text);
10.         
11.         System.out.println("Found URLs:");
12.         while (matcher.find()) {
13.             System.out.println(matcher.group());
14.         }
15.     }
16.    
17.     public static void main(String[] args) {
18.         String text = "Visit our website at https://www.example.com or " +
19.                      "check out our blog at http://blog.example.com/post?id=123. " +
20.                      "You can also download files from ftp://files.example.com/data.zip.";
21.         
22.         findURLs(text);
23.     }
24. }
25. /*
26. 输出:
27. Found URLs:
28. https://www.example.com
29. http://blog.example.com/post?id=123
30. ftp://files.example.com/data.zip
31. */

复制代码

替换

正则表达式可以用于替换文本中符合特定模式的内容。

2. // 示例：敏感信息脱敏
3. public class DataMasker {
4.     public static String maskEmail(String email) {
5.         return email.replaceAll("(^[^@]+)|(@[^@]+$)",
6.             match -> match.group(1) != null ?
7.             match.group(1).substring(0, Math.min(2, match.group(1).length())) + "*****" :
8.             match.group(2));
9.     }
10.    
11.     public static String maskPhoneNumber(String phoneNumber) {
12.         return phoneNumber.replaceAll("\\d(?=\\d{4})", "*");
13.     }
14.    
15.     public static String maskCreditCard(String cardNumber) {
16.         return cardNumber.replaceAll("\\d(?=\\d{4})", "*");
17.     }
18.    
19.     public static void main(String[] args) {
20.         String email = "john.doe@example.com";
21.         String phoneNumber = "123-456-7890";
22.         String creditCard = "1234-5678-9012-3456";
23.         
24.         System.out.println("Original email: " + email);
25.         System.out.println("Masked email: " + maskEmail(email));
26.         
27.         System.out.println("Original phone: " + phoneNumber);
28.         System.out.println("Masked phone: " + maskPhoneNumber(phoneNumber));
29.         
30.         System.out.println("Original card: " + creditCard);
31.         System.out.println("Masked card: " + maskCreditCard(creditCard));
32.     }
33. }
34. /*
35. 输出:
36. Original email: john.doe@example.com
37. Masked email: jo*****@example.com
38. Original phone: 123-456-7890
39. Masked phone: ***-***-7890
40. Original card: 1234-5678-9012-3456
41. Masked card: ****-****-****-3456
42. */

复制代码

分割

正则表达式可以用于根据特定模式分割字符串。

2. // 示例：CSV解析
3. public class CSVParser {
4.     public static String[] parseCSVLine(String line) {
5.         // 处理带引号的CSV字段
6.         String csvRegex = ",(?=(?:[^"]*"[^"]*")*[^"]*$)";
7.         return line.split(csvRegex);
8.     }
9.    
10.     public static void main(String[] args) {
11.         String csvLine = "John,Doe,"New York, NY",30,"$50,000"";
12.         String[] fields = parseCSVLine(csvLine);
13.         
14.         System.out.println("CSV fields:");
15.         for (int i = 0; i < fields.length; i++) {
16.             System.out.println((i + 1) + ": " + fields[i]);
17.         }
18.     }
19. }
20. /*
21. 输出:
22. CSV fields:
23. 1: John
24. 2: Doe
25. 3: "New York, NY"
26. 4: 30
27. 5: "$50,000"
28. */

复制代码

高级正则表达式技巧

贪婪与 reluctant 量词

量词默认是贪婪的（greedy），会尽可能多地匹配字符。 reluctant 量词（也称为非贪婪或懒惰量词）会尽可能少地匹配字符。

• 贪婪量词：*,+,?,{n},{n,},{n,m}
• Reluctant量词：*?,+?,??,{n}?,{n,}?,{n,m}?
• Possessive量词：*+,++,?+,{n}+,{n,}+,{n,m}+

2. // 示例：贪婪与reluctant量词
3. public class QuantifierExample {
4.     public static void main(String[] args) {
5.         String text = "<div>Content 1</div><div>Content 2</div>";
6.         
7.         // 贪婪匹配 - 匹配尽可能多的字符
8.         Pattern greedyPattern = Pattern.compile("<div>.*</div>");
9.         Matcher greedyMatcher = greedyPattern.matcher(text);
10.         if (greedyMatcher.find()) {
11.             System.out.println("Greedy match: " + greedyMatcher.group());
12.         }
13.         // 输出: Greedy match: <div>Content 1</div><div>Content 2</div>
14.         
15.         // Reluctant匹配 - 匹配尽可能少的字符
16.         Pattern reluctantPattern = Pattern.compile("<div>.*?</div>");
17.         Matcher reluctantMatcher = reluctantPattern.matcher(text);
18.         while (reluctantMatcher.find()) {
19.             System.out.println("Reluctant match: " + reluctantMatcher.group());
20.         }
21.         /*
22.         输出:
23.         Reluctant match: <div>Content 1</div>
24.         Reluctant match: <div>Content 2</div>
25.         */
26.     }
27. }

复制代码

零宽断言

零宽断言（zero-width assertions）用于匹配某个位置，而不是字符本身。它们不消耗字符，只进行判断。

• 正向先行断言（Positive Lookahead）：(?=pattern)，断言当前位置后面能匹配pattern
• 负向先行断言（Negative Lookahead）：(?!pattern)，断言当前位置后面不能匹配pattern
• 正向后行断言（Positive Lookbehind）：(?<=pattern)，断言当前位置前面能匹配pattern
• 负向后行断言（Negative Lookbehind）：(?<!pattern)，断言当前位置前面不能匹配pattern

2. // 示例：使用零宽断言
3. public class ZeroWidthAssertionExample {
4.     public static void main(String[] args) {
5.         String text = "apple banana orange grape kiwi";
6.         
7.         // 正向先行断言 - 匹配后面跟着空格的单词
8.         Pattern lookaheadPattern = Pattern.compile("\\w+(?=\\s)");
9.         Matcher lookaheadMatcher = lookaheadPattern.matcher(text);
10.         System.out.println("Positive lookahead matches:");
11.         while (lookaheadMatcher.find()) {
12.             System.out.println(lookaheadMatcher.group());
13.         }
14.         /*
15.         输出:
16.         Positive lookahead matches:
17.         apple
18.         banana
19.         orange
20.         grape
21.         */
22.         
23.         // 负向先行断言 - 匹配后面不跟着空格的单词
24.         Pattern negativeLookaheadPattern = Pattern.compile("\\w+(?!\\s)");
25.         Matcher negativeLookaheadMatcher = negativeLookaheadPattern.matcher(text);
26.         System.out.println("\nNegative lookahead matches:");
27.         while (negativeLookaheadMatcher.find()) {
28.             System.out.println(negativeLookaheadMatcher.group());
29.         }
30.         /*
31.         输出:
32.         Negative lookahead matches:
33.         e
34.         a
35.         e
36.         e
37.         kiwi
38.         */
39.         
40.         // 正向后行断言 - 匹配前面是空格的单词
41.         Pattern lookbehindPattern = Pattern.compile("(?<=\\s)\\w+");
42.         Matcher lookbehindMatcher = lookbehindPattern.matcher(text);
43.         System.out.println("\nPositive lookbehind matches:");
44.         while (lookbehindMatcher.find()) {
45.             System.out.println(lookbehindMatcher.group());
46.         }
47.         /*
48.         输出:
49.         Positive lookbehind matches:
50.         banana
51.         orange
52.         grape
53.         kiwi
54.         */
55.     }
56. }

复制代码

回溯与性能优化

正则表达式引擎使用回溯（backtracking）来尝试不同的匹配路径。复杂的正则表达式可能导致大量的回溯，影响性能。

2. // 示例：正则表达式性能优化
3. public class RegexPerformanceExample {
4.     public static void main(String[] args) {
5.         String text = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaX";
6.         
7.         // 容易导致灾难性回溯的正则表达式
8.         String badRegex = "(a+)+";
9.         long startTime = System.currentTimeMillis();
10.         Pattern badPattern = Pattern.compile(badRegex);
11.         Matcher badMatcher = badPattern.matcher(text);
12.         if (badMatcher.matches()) {
13.             System.out.println("Bad regex matched");
14.         }
15.         long endTime = System.currentTimeMillis();
16.         System.out.println("Bad regex time: " + (endTime - startTime) + "ms");
17.         
18.         // 优化后的正则表达式
19.         String goodRegex = "a+";
20.         startTime = System.currentTimeMillis();
21.         Pattern goodPattern = Pattern.compile(goodRegex);
22.         Matcher goodMatcher = goodPattern.matcher(text);
23.         if (goodMatcher.matches()) {
24.             System.out.println("Good regex matched");
25.         }
26.         endTime = System.currentTimeMillis();
27.         System.out.println("Good regex time: " + (endTime - startTime) + "ms");
28.     }
29. }
30. /*
31. 输出:
32. Bad regex matched
33. Bad regex time: 15ms
34. Good regex matched
35. Good regex time: 0ms
36. */

复制代码

正则表达式性能优化技巧：

1. 避免嵌套量词，如(a+)+
2. 使用更具体的字符类，如[0-9]代替\d
3. 使用占有量词（possessive quantifiers）避免不必要的回溯，如a++代替a+
4. 使用非捕获组(?:pattern)代替捕获组(pattern)
5. 预编译正则表达式并重用Pattern对象
6. 使用锚点^和$限制匹配范围
7. 避免过度使用通配符.*

实际开发案例

表单验证

在实际开发中，表单验证是正则表达式的常见应用场景。

2. // 示例：用户注册表单验证
3. public class RegistrationValidator {
4.     // 用户名：4-16个字符，只能包含字母、数字和下划线
5.     private static final String USERNAME_REGEX = "^[a-zA-Z0-9_]{4,16}$";
6.    
7.     // 密码：至少8个字符，至少包含一个大写字母、一个小写字母、一个数字和一个特殊字符
8.     private static final String PASSWORD_REGEX =
9.         "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$";
10.    
11.     // 邮箱：标准邮箱格式
12.     private static final String EMAIL_REGEX =
13.         "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
14.    
15.     // 手机号：简单验证，11位数字
16.     private static final String PHONE_REGEX = "^\\d{11}$";
17.    
18.     public static boolean validateUsername(String username) {
19.         return username != null && username.matches(USERNAME_REGEX);
20.     }
21.    
22.     public static boolean validatePassword(String password) {
23.         return password != null && password.matches(PASSWORD_REGEX);
24.     }
25.    
26.     public static boolean validateEmail(String email) {
27.         return email != null && email.matches(EMAIL_REGEX);
28.     }
29.    
30.     public static boolean validatePhone(String phone) {
31.         return phone != null && phone.matches(PHONE_REGEX);
32.     }
33.    
34.     public static void main(String[] args) {
35.         String username = "john_doe123";
36.         String password = "SecurePass123!";
37.         String email = "john.doe@example.com";
38.         String phone = "12345678901";
39.         
40.         System.out.println("Username " + username + " is " +
41.             (validateUsername(username) ? "valid" : "invalid"));
42.         System.out.println("Password is " +
43.             (validatePassword(password) ? "valid" : "invalid"));
44.         System.out.println("Email " + email + " is " +
45.             (validateEmail(email) ? "valid" : "invalid"));
46.         System.out.println("Phone " + phone + " is " +
47.             (validatePhone(phone) ? "valid" : "invalid"));
48.     }
49. }
50. /*
51. 输出:
52. Username john_doe123 is valid
53. Password is valid
54. Email john.doe@example.com is valid
55. Phone 12345678901 is valid
56. */

复制代码

日志分析

日志分析是正则表达式的另一个重要应用场景，可以从大量日志中提取有用信息。

2. // 示例：Web服务器日志分析
3. public class LogAnalyzer {
4.     // Apache Common Log Format: IP - - [date] "request" status size
5.     private static final String LOG_REGEX =
6.         "^(\\S+) \\S+ \\S+ \\[([^\\]]+)\\] "([^"]+)" (\\d+) (\\S+)$";
7.    
8.     public static void analyzeLog(String logLine) {
9.         Pattern pattern = Pattern.compile(LOG_REGEX);
10.         Matcher matcher = pattern.matcher(logLine);
11.         
12.         if (matcher.matches()) {
13.             String ip = matcher.group(1);
14.             String timestamp = matcher.group(2);
15.             String request = matcher.group(3);
16.             int status = Integer.parseInt(matcher.group(4));
17.             String size = matcher.group(5);
18.             
19.             System.out.println("IP: " + ip);
20.             System.out.println("Timestamp: " + timestamp);
21.             System.out.println("Request: " + request);
22.             System.out.println("Status: " + status);
23.             System.out.println("Size: " + size);
24.             
25.             // 分析请求类型
26.             String requestType = request.split(" ")[0];
27.             System.out.println("Request Type: " + requestType);
28.             
29.             // 分析请求路径
30.             String[] requestParts = request.split(" ");
31.             if (requestParts.length > 1) {
32.                 String path = requestParts[1];
33.                 System.out.println("Path: " + path);
34.                
35.                 // 提取文件扩展名
36.                 if (path.contains(".")) {
37.                     String extension = path.substring(path.lastIndexOf('.') + 1);
38.                     System.out.println("File Extension: " + extension);
39.                 }
40.             }
41.             
42.             // 分析状态码
43.             if (status >= 400) {
44.                 System.out.println("*** ERROR REQUEST ***");
45.             }
46.         } else {
47.             System.out.println("Invalid log format");
48.         }
49.     }
50.    
51.     public static void main(String[] args) {
52.         String logLine = "192.168.1.1 - - [25/Dec/2022:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234";
53.         analyzeLog(logLine);
54.     }
55. }
56. /*
57. 输出:
58. IP: 192.168.1.1
59. Timestamp: 25/Dec/2022:10:00:00 +0000
60. Request: GET /index.html HTTP/1.1
61. Status: 200
62. Size: 1234
63. Request Type: GET
64. Path: /index.html
65. File Extension: html
66. */

复制代码

数据提取

从文本中提取结构化数据是正则表达式的强项。

2. // 示例：从HTML中提取链接
3. public class LinkExtractor {
4.     public static List<String> extractLinks(String html) {
5.         List<String> links = new ArrayList<>();
6.         
7.         // 匹配<a>标签中的href属性
8.         String linkRegex = "<a\\s+[^>]*href\\s*=\\s*['"]([^'"]+)['"][^>]*>";
9.         Pattern pattern = Pattern.compile(linkRegex);
10.         Matcher matcher = pattern.matcher(html);
11.         
12.         while (matcher.find()) {
13.             links.add(matcher.group(1));
14.         }
15.         
16.         return links;
17.     }
18.    
19.     public static void main(String[] args) {
20.         String html = "<html><body>" +
21.                      "<a href='https://www.example.com'>Example</a>" +
22.                      "<a href="/about">About Us</a>" +
23.                      "<a href='contact.html'>Contact</a>" +
24.                      "<a href = "https://www.google.com">Google</a>" +
25.                      "</body></html>";
26.         
27.         List<String> links = extractLinks(html);
28.         System.out.println("Extracted links:");
29.         for (String link : links) {
30.             System.out.println(link);
31.         }
32.     }
33. }
34. /*
35. 输出:
36. Extracted links:
37. https://www.example.com
38. /about
39. contact.html
40. https://www.google.com
41. */

复制代码

文本处理

文本处理是正则表达式的经典应用场景，包括清理、格式化和转换文本。

2. // 示例：文本清理和标准化
3. public class TextCleaner {
4.     // 移除HTML标签
5.     public static String removeHtmlTags(String html) {
6.         return html.replaceAll("<[^>]*>", "");
7.     }
8.    
9.     // 标准化空白字符
10.     public static String normalizeWhitespace(String text) {
11.         return text.replaceAll("\\s+", " ").trim();
12.     }
13.    
14.     // 移除特殊字符，只保留字母、数字和空格
15.     public static String removeSpecialChars(String text) {
16.         return text.replaceAll("[^a-zA-Z0-9\\s]", "");
17.     }
18.    
19.     // 转换为标题格式（每个单词首字母大写）
20.     public static String toTitleCase(String text) {
21.         return text.replaceAll("\\b(\\w)(\\w*)\\b",
22.             match -> match.group(1).toUpperCase() + match.group(2).toLowerCase());
23.     }
24.    
25.     public static void main(String[] args) {
26.         String html = "<p>This is a <b>sample</b> text with <i>HTML</i> tags.</p>";
27.         System.out.println("Original HTML: " + html);
28.         System.out.println("Without HTML tags: " + removeHtmlTags(html));
29.         
30.         String messyText = "This   has   multiple   spaces   and\ttabs\nand\nnewlines";
31.         System.out.println("\nOriginal text: " + messyText);
32.         System.out.println("Normalized text: " + normalizeWhitespace(messyText));
33.         
34.         String specialCharsText = "Hello! @World# $123%";
35.         System.out.println("\nOriginal text: " + specialCharsText);
36.         System.out.println("Without special chars: " + removeSpecialChars(specialCharsText));
37.         
38.         String titleText = "this is a TITLE";
39.         System.out.println("\nOriginal text: " + titleText);
40.         System.out.println("Title case: " + toTitleCase(titleText));
41.     }
42. }
43. /*
44. 输出:
45. Original HTML: <p>This is a <b>sample</b> text with <i>HTML</i> tags.</p>
46. Without HTML tags: This is a sample text with HTML tags.
48. Original text: This   has   multiple   spaces   and        tabs
49. and
50. newlines
51. Normalized text: This has multiple spaces and tabs and newlines
53. Original text: Hello! @World# $123%
54. Without special chars: Hello World 123
56. Original text: this is a TITLE
57. Title case: This Is A Title
58. */

复制代码

最佳实践与常见陷阱

最佳实践

1. 预编译正则表达式：对于频繁使用的正则表达式，应该预编译并重用Pattern对象，而不是每次使用都重新编译。

2. // 不好的做法
3. public boolean isValidEmail(String email) {
4.     return email.matches("^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$");
5. }
7. // 好的做法
8. private static final Pattern EMAIL_PATTERN =
9.     Pattern.compile("^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$");
11. public boolean isValidEmail(String email) {
12.     return email != null && EMAIL_PATTERN.matcher(email).matches();
13. }

复制代码

1. 使用适当的匹配方法：根据需求选择合适的匹配方法，如matches()、lookingAt()或find()。

2. String text = "The price is $123.45";
3. Pattern pattern = Pattern.compile("\\d+");
5. // matches()尝试将整个区域与模式匹配
6. boolean fullMatch = pattern.matcher(text).matches(); // 返回false
8. // lookingAt()尝试从区域开头开始匹配模式
9. boolean startMatch = pattern.matcher(text).lookingAt(); // 返回false
11. // find()尝试查找与模式匹配的输入序列的下一个子序列
12. boolean partialMatch = pattern.matcher(text).find(); // 返回true

复制代码

1. 使用非捕获组提高性能：如果不需要捕获匹配的文本，使用非捕获组(?:pattern)代替捕获组(pattern)。

2. // 不好的做法
3. String regex = "(\\d{4})-(\\d{2})-(\\d{2})";
5. // 好的做法（如果不需要捕获分组）
6. String regex = "(?:\\d{4})-(?:\\d{2})-(?:\\d{2})";

复制代码

1. 使用命名捕获组提高可读性：对于复杂的正则表达式，使用命名捕获组(?<name>pattern)代替数字索引。

2. // 不好的做法
3. String regex = "(\\d{4})-(\\d{2})-(\\d{2})";
4. Matcher matcher = Pattern.compile(regex).matcher("2023-01-01");
5. if (matcher.matches()) {
6.     String year = matcher.group(1);
7.     String month = matcher.group(2);
8.     String day = matcher.group(3);
9. }
11. // 好的做法
12. String regex = "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})";
13. Matcher matcher = Pattern.compile(regex).matcher("2023-01-01");
14. if (matcher.matches()) {
15.     String year = matcher.group("year");
16.     String month = matcher.group("month");
17.     String day = matcher.group("day");
18. }

复制代码

常见陷阱

1. 忽略转义字符：在Java字符串中，反斜杠\需要转义为\\，因此正则表达式中的\d在Java字符串中应写成\\d。

2. // 不好的做法
3. String regex = "\d+"; // 编译错误
5. // 好的做法
6. String regex = "\\d+";

复制代码

1. 过度使用通配符：过度使用.*或.+可能导致性能问题和意外匹配。

2. // 不好的做法
3. String regex = ".*foo.*"; // 可能匹配过多内容
5. // 好的做法
6. String regex = "\\bfoo\\b"; // 只匹配单词"foo"

复制代码

1. 忽略回溯问题：复杂的正则表达式可能导致灾难性回溯，影响性能。

2. // 不好的做法，可能导致灾难性回溯
3. String regex = "(a+)+";
5. // 好的做法
6. String regex = "a+";

复制代码

1. 忽略输入验证：在使用正则表达式处理用户输入前，应该验证输入是否为null或空。

2. // 不好的做法
3. public boolean isValid(String input) {
4.     return input.matches("^[a-z]+$");
5. }
7. // 好的做法
8. public boolean isValid(String input) {
9.     return input != null && !input.isEmpty() && input.matches("^[a-z]+$");
10. }

复制代码

总结

正则表达式是Java中处理文本数据的强大工具，通过掌握其基础语法和高级技巧，开发者可以高效地解决各种文本处理问题。本文从正则表达式的基础语法开始，介绍了Java中的正则表达式API，探讨了常见的字符串操作应用，并分享了高级技巧和最佳实践。

在实际开发中，正则表达式广泛应用于表单验证、日志分析、数据提取和文本处理等场景。通过预编译正则表达式、使用非捕获组、命名捕获组等技巧，可以提高正则表达式的性能和可读性。同时，避免常见陷阱，如忽略转义字符、过度使用通配符、忽略回溯问题等，可以确保正则表达式的正确性和效率。

掌握正则表达式是Java开发者的必备技能，通过不断实践和学习，开发者可以充分利用正则表达式的强大功能，解决实际开发中的文本处理难题。