java
☘ 主页 > 软件编程 > java >

Java常用正则表达式及使用方法(Pattern和Matcher类)

2026-09-27 | 佚名 | 点击：次

在 Java 中，Pattern 和 Matcher 类是 java.util.regex 包的核心，用于处理正则表达式。

Pattern类

Pattern 类表示编译后的正则表达式，它提供了一种将正则表达式字符串编译成可执行对象的方式，以便后续用于匹配操作。

常用方法

  1. compile(String regex)：这是一个静态方法，用于将给定的正则表达式字符串编译为 Pattern 对象。
  2. matcher(CharSequence input)：创建一个 Matcher 对象，该对象将使用编译好的正则表达式对指定的输入字符串进行匹配操作。
  3. split(CharSequence input)：根据正则表达式将输入的字符串分割成字符串数组。

示例代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

import java.util.regex.Pattern;

 

public class PatternExample {

    public static void main(String[] args) {

        // 编译正则表达式

        Pattern pattern = Pattern.compile("\\d+");

 

        // 使用 split 方法分割字符串

        String input = "abc123def456ghi";

        String[] parts = pattern.split(input);

        for (String part : parts) {

            System.out.println(part);

        }

    }

}

在上述代码中，首先使用 Pattern.compile("\\d+") 编译了一个匹配一个或多个数字的正则表达式。然后使用 split 方法将输入字符串按照数字进行分割，最后打印分割后的结果。

Matcher类

Matcher 类用于对输入字符串执行匹配操作，它提供了多种方法来查找、替换和提取匹配的子字符串。

常用方法

  1. find()：尝试在输入字符串中查找下一个匹配的子字符串，如果找到则返回 true，否则返回 false。
  2. matches()：尝试将整个输入字符串与正则表达式进行匹配，如果完全匹配则返回 true，否则返回 false。
  3. group()：返回上一次匹配操作所匹配的子字符串。
  4. replaceAll(String replacement)：将输入字符串中所有匹配的子字符串替换为指定的字符串。

示例代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class MatcherExample {

    public static void main(String[] args) {

        // 编译正则表达式

        Pattern pattern = Pattern.compile("\\d+");

        // 创建 Matcher 对象

        Matcher matcher = pattern.matcher("abc123def456ghi");

 

        // 使用 find 方法查找匹配的子字符串

        while (matcher.find()) {

            System.out.println("找到匹配项: " + matcher.group());

        }

 

        // 使用 replaceAll 方法替换匹配的子字符串

        String result = matcher.replaceAll("X");

        System.out.println("替换后的字符串: " + result);

    }

}

在上述代码中，首先编译了一个匹配一个或多个数字的正则表达式，并创建了一个 Matcher 对象。然后使用 find 方法在输入字符串中查找所有匹配的数字，并打印出来。最后使用 replaceAll 方法将所有匹配的数字替换为字符 X，并打印替换后的字符串。

相关网站

正则表达式

正则表达式是用于匹配、查找和替换文本模式的强大工具，在许多编程语言和文本处理工具中都有广泛应用。以下是一些常用的正则表达式及其用途：

1. 匹配数字

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class DigitMatching {

    public static void main(String[] args) {

        String input = "abc123";

        // 匹配单个数字

        Pattern singleDigitPattern = Pattern.compile("\\d");

        Matcher singleDigitMatcher = singleDigitPattern.matcher(input);

        while (singleDigitMatcher.find()) {

            System.out.println("单个数字匹配结果: " + singleDigitMatcher.group());

        }

 

        // 匹配多个数字

        Pattern multipleDigitPattern = Pattern.compile("\\d+");

        Matcher multipleDigitMatcher = multipleDigitPattern.matcher(input);

        while (multipleDigitMatcher.find()) {

            System.out.println("多个数字匹配结果: " + multipleDigitMatcher.group());

        }

    }

}

2. 匹配字母

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

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class LetterMatching {

    public static void main(String[] args) {

        String input = "ABCabc";

 

        // 匹配单个小写字母

        Pattern lowerCasePattern = Pattern.compile("[a-z]");

        Matcher lowerCaseMatcher = lowerCasePattern.matcher(input);

        while (lowerCaseMatcher.find()) {

            System.out.println("单个小写字母匹配结果: " + lowerCaseMatcher.group());

        }

 

        // 匹配单个大写字母

        Pattern upperCasePattern = Pattern.compile("[A-Z]");

        Matcher upperCaseMatcher = upperCasePattern.matcher(input);

        while (upperTypeCaseMatcher.find()) {

            System.out.println("单个大写字母匹配结果: " + upperCaseMatcher.group());

        }

 

        // 匹配单个字母（不区分大小写）

        Pattern anyCasePattern = Pattern.compile("[a-zA-Z]");

        Matcher anyCaseMatcher = anyCasePattern.matcher(input);

        while (anyCaseMatcher.find()) {

            System.out.println("单个字母（不区分大小写）匹配结果: " + anyCaseMatcher.group());

        }

    }

}

3. 匹配字母和数字

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class AlphanumericMatching {

    public static void main(String[] args) {

        String input = "abc123@#$";

 

        // 匹配单个字母或数字

        Pattern singleAlphanumericPattern = Pattern.compile("[a-zA-Z0-9]");

        Matcher singleAlphanumericMatcher = singleAlphanumericPattern.matcher(input);

        while (singleAlphanumericMatcher.find()) {

            System.out.println("单个字母或数字匹配结果: " + singleAlphanumericMatcher.group());

        }

 

        // 匹配多个字母或数字

        Pattern multipleAlphanumericPattern = Pattern.compile("[a-zA-Z0-9]+");

        Matcher multipleAlphanumericMatcher = multipleAlphanumericPattern.matcher(input);

        while (multipleAlphanumericMatcher.find()) {

            System.out.println("多个字母或数字匹配结果: " + multipleAlphanumericMatcher.group());

        }

    }

}

4. 匹配空白字符

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class WhitespaceMatching {

    public static void main(String[] args) {

        String input = "abc  123";

 

        // 匹配单个空白字符

        Pattern singleWhitespacePattern = Pattern.compile("\\s");

        Matcher singleWhitespaceMatcher = singleWhitespacePattern.matcher(input);

        while (singleWhitespaceMatcher.find()) {

            System.out.println("单个空白字符匹配结果: " + singleWhitespaceMatcher.group());

        }

 

        // 匹配多个空白字符

        Pattern multipleWhitespacePattern = Pattern.compile("\\s+");

        Matcher multipleWhitespaceMatcher = multipleWhitespacePattern.matcher(input);

        while (multipleWhitespaceMatcher.find()) {

            System.out.println("多个空白字符匹配结果: " + multipleWhitespaceMatcher.group());

        }

    }

}

5. 匹配邮箱地址

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class EmailMatching {

    public static void main(String[] args) {

        String email = "test@example.com";

        String patternStr = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";

        Pattern pattern = Pattern.compile(patternStr);

        Matcher matcher = pattern.matcher(email);

        if (matcher.matches()) {

            System.out.println("有效邮箱地址");

        } else {

            System.out.println("无效邮箱地址");

        }

    }

}

6. 匹配手机号码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class PhoneNumberMatching {

    public static void main(String[] args) {

        String phone = "13800138000";

        String patternStr = "^1[3-9]\\d{9}$";

        Pattern pattern = Pattern.compile(patternStr);

        Matcher matcher = pattern.matcher(phone);

        if (matcher.matches()) {

            System.out.println("有效手机号码");

        } else {

            System.out.println("无效手机号码");

        }

    }

}

关于匹配邮箱详解：

"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";符号的含义

1. 定界符

  • ^：表示匹配字符串的开始位置。在该正则表达式中，它确保匹配是从字符串的起始处开始的，即邮箱地址的起始部分必须符合后续的规则。
  • $：表示匹配字符串的结束位置。意味着整个字符串必须完全匹配正则表达式所定义的模式，直到字符串结束。结合 ^ 和 $ 使用，能保证整个字符串是一个完整的邮箱地址，而不是包含在其他文本中的部分邮箱地址。

2. 用户名部分：[a-zA-Z0-9._%+-]+

  • [a-zA-Z0-9._%+-]：这是一个字符类，它定义了一组允许的字符。
    • a-zA-Z：表示所有的大小写英文字母，即 A 到 Z 和 a 到 z。
    • 0-9：表示所有的数字，即 0 到 9。
    • .、_、%、+、-：这些是特定的符号，在邮箱用户名中是允许出现的。
  • +：是一个量词，表示前面的字符类（即 [a-zA-Z0-9._%+-]）必须出现一次或多次。也就是说，邮箱用户名至少要有一个字符，并且只能由上述定义的字符组成。

3.@：

这是邮箱地址中用于分隔用户名和域名的固定符号，在正则表达式中直接使用该字符来匹配实际邮箱地址中的 @ 符号。

4. 域名部分：[a-zA-Z0-9.-]+

  • [a-zA-Z0-9.-]：同样是一个字符类，允许的字符包括大小写英文字母、数字、点号 . 和连字符 -。在域名中，这些字符是常见的组成部分。
  • +：表示前面的字符类必须出现一次或多次，即域名部分至少要有一个字符，且由上述定义的字符组成。

5.\\.：

  • 点号 . 在正则表达式中有特殊含义，表示匹配任意单个字符。为了匹配实际的点号（即邮箱地址中的域名分隔符），需要使用反斜杠 \ 进行转义。由于在 Java 字符串中，反斜杠本身也需要转义，所以写成 \\.。

6. 顶级域名部分：[a-zA-Z]{2,}

  • [a-zA-Z]：表示所有的大小写英文字母。
  • {2,}：是一个量词，表示前面的字符类（即 [a-zA-Z]）必须出现至少 2 次。这是因为常见的顶级域名（如 .com、.org、.cn 等）通常至少由两个字母组成。
原文链接：
相关文章
最新更新