下一页 → ← 上一页

Java 正则表达式 (Regex)

2025年4月2日 | 阅读11分钟

Java Regex 或正则表达式是一个用于定义搜索或操作字符串的模式的 API。

它被广泛用于定义字符串的约束，例如密码和电子邮件验证。在学习 Java 正则表达式教程之后，您将能够通过 Java Regex 测试工具测试您的正则表达式。

Java Regex API 在 java.util.regex 包中提供了 1 个接口和 3 个类。

java.util.regex 包

Matcher 和 Pattern 类提供了 Java 正则表达式的功能。 java.util.regex 包为正则表达式提供了以下类和接口。

MatchResult 接口
Matcher 类
Pattern 类
PatternSyntaxException 类

Java Regex API

Matcher 类

它实现了 MatchResult 接口。它是一个正则表达式引擎，用于对字符序列执行匹配操作。

编号。	方法	描述
1	boolean matches()	测试正则表达式是否与模式匹配。
2	boolean find()	找到与模式匹配的下一个表达式。
3	boolean find(int start)	从给定的起始数字查找与模式匹配的下一个表达式。
4	String group()	返回匹配的子序列。
5	int start()	返回匹配子序列的起始索引。
6	int end()	返回匹配子序列的结束索引。
7	int groupCount()	返回匹配子序列的总数。

Pattern 类

它是正则表达式的编译版本。它用于为正则表达式引擎定义模式。

编号。	方法	描述
1	static Pattern compile(String regex)	编译给定的正则表达式并返回 Pattern 的实例。
2	Matcher matcher(CharSequence input)	创建一个将给定输入与模式匹配的匹配器。
3	static boolean matches(String regex, CharSequence input)	它作为 compile 和 matcher 方法的组合。它编译正则表达式并将给定的输入与模式匹配。
4	String[] split(CharSequence input)	在给定模式的匹配项周围分割给定的输入字符串。
5	String pattern()	返回正则表达式模式。

Java 正则表达式示例

有三种方法可以在 Java 中编写正则表达式示例。

示例

//Creating an example to understand the use of Java Regular Expression
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main{  
public static void main(String args[]){  
//1st way  
Pattern p = Pattern.compile(".s");//. represents single character  
Matcher m = p.matcher("as");  
boolean b = m.matches();  
  
//2nd way  
boolean b2=Pattern.compile(".s").matcher("as").matches();  
  
//3rd way  
boolean b3 = Pattern.matches(".s", "as");  
  
System.out.println(b+" "+b2+" "+b3);  
}}  

编译并运行

输出

true true true

正则表达式 . 示例

. (点) 表示单个字符。

示例

//Java Program to understand the use of dot . quantifier
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println(Pattern.matches(".s", "as"));//true (2nd char is s)  
System.out.println(Pattern.matches(".s", "mk"));//false (2nd char is not s)  
System.out.println(Pattern.matches(".s", "mst"));//false (has more than 2 char)  
System.out.println(Pattern.matches(".s", "amms"));//false (has more than 2 char)  
System.out.println(Pattern.matches("..s", "mas"));//true (3rd char is s)  
}}

编译并运行

Java 正则表达式字符类

编号。	字符类	描述
1	[abc]	a、b 或 c（简单类）
2	[^abc]	除了 a、b 或 c 之外的任何字符（否定）
3	[a-zA-Z]	a 到 z 或 A 到 Z，包括在内（范围）
4	[a-d[m-p]]	a 到 d，或 m 到 p：[a-dm-p]（并集）
5	[a-z&&[def]]	d、e 或 f（交集）
6	[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减法）
7	[a-z&&[^m-p]]	a 到 z，而不是 m 到 p：[a-lq-z]（减法）

Java 正则表达式：字符类示例

示例

//Java Program to understand the use of Regex Character class
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println(Pattern.matches("[amn]", "abcd"));//false (not a or m or n)  
System.out.println(Pattern.matches("[amn]", "a"));//true (among a or m or n)  
System.out.println(Pattern.matches("[amn]", "ammmna"));//false (m and a comes more than once)  
}} 

编译并运行

Java 正则表达式量词

量词指定字符出现的次数。

Regex	描述
X?	X 出现一次或根本不出现
X+	X 出现一次或多次
X*	X 出现零次或多次
X{n}	X 仅出现 n 次
X{n,}	X 出现 n 次或更多次
X{y,z}	X 至少出现 y 次但少于 z 次

Java 正则表达式：字符类和量词示例

示例

//Java Program to understand the use of regex quantifiers
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println("? quantifier ....");  
System.out.println(Pattern.matches("[amn]?", "a"));//true (a or m or n comes one time)  
System.out.println(Pattern.matches("[amn]?", "aaa"));//false (a comes more than one time)  
System.out.println(Pattern.matches("[amn]?", "aammmnn"));//false (a m and n comes more than one time)  
System.out.println(Pattern.matches("[amn]?", "aazzta"));//false (a comes more than one time)  
System.out.println(Pattern.matches("[amn]?", "am"));//false (a or m or n must come one time)  
  
System.out.println("+ quantifier ....");  
System.out.println(Pattern.matches("[amn]+", "a"));//true (a or m or n once or more times)  
System.out.println(Pattern.matches("[amn]+", "aaa"));//true (a comes more than one time)  
System.out.println(Pattern.matches("[amn]+", "aammmnn"));//true (a or m or n comes more than once)  
System.out.println(Pattern.matches("[amn]+", "aazzta"));//false (z and t are not matching pattern)  
  
System.out.println("* quantifier ....");  
System.out.println(Pattern.matches("[amn]*", "ammmna"));//true (a or m or n may come zero or more times)  
  
}}  

编译并运行

Java 正则表达式元字符

正则表达式元字符用作简写。

Regex	描述
.	任何字符（可能匹配或可能不匹配终止符）
\d	任何数字，简写为 [0-9]
\D	任何非数字，简写为 [^0-9]
\s	任何空白字符，简写为 [\t\n\x0B\f\r]
\S	任何非空白字符，简写为 [^\s]
\w	任何单词字符，简写为 [a-zA-Z_0-9]
\W	任何非单词字符，简写为 [^\w]
\b	一个单词边界
\B	一个非单词边界

Java 正则表达式：元字符示例

示例

//Java Program to understand the use of Regex Metacharacters
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println("metacharacters d....");//d means digit  
  
System.out.println(Pattern.matches("\\d", "abc"));//false (non-digit)  
System.out.println(Pattern.matches("\\d", "1"));//true (digit and comes once)  
System.out.println(Pattern.matches("\\d", "4443"));//false (digit but comes more than once)  
System.out.println(Pattern.matches("\\d", "323abc"));//false (digit and char)  
  
System.out.println("metacharacters D....");//D means non-digit  
  
System.out.println(Pattern.matches("\\D", "abc"));//false (non-digit but comes more than once)  
System.out.println(Pattern.matches("\\D", "1"));//false (digit)  
System.out.println(Pattern.matches("\\D", "4443"));//false (digit)  
System.out.println(Pattern.matches("\\D", "323abc"));//false (digit and char)  
System.out.println(Pattern.matches("\\D", "m"));//true (non-digit and comes once)  
  
System.out.println("metacharacters D with quantifier....");  
System.out.println(Pattern.matches("\\D*", "mak"));//true (non-digit and may come 0 or more times)  
  
}}  

Java 正则表达式问题 1

创建一个正则表达式，它只接受字母数字字符。它的长度必须只有六个字符。

import java.util.regex.*;
class RegexExample6{
public static void main(String args[]){
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "arun32"));//true
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "kkvarun32"));//false (more than 6 char)
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "JA2Uk2"));//true
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "arun$2"));//false ($ is not matched)
}}

正则表达式问题 2

/*Create a regular expression that accepts 10 digit numeric characters
 starting with 7, 8 or 9 only.*/

import java.util.regex.*;
class RegexExample7{
public static void main(String args[]){
System.out.println("by character classes and quantifiers ...");
System.out.println(Pattern.matches("[789]{1}[0-9]{9}", "9953038949"));//true
System.out.println(Pattern.matches("[789][0-9]{9}", "9953038949"));//true

System.out.println(Pattern.matches("[789][0-9]{9}", "99530389490"));//false (11 characters)
System.out.println(Pattern.matches("[789][0-9]{9}", "6953038949"));//false (starts from 6)
System.out.println(Pattern.matches("[789][0-9]{9}", "8853038949"));//true

System.out.println("by metacharacters ...");
System.out.println(Pattern.matches("[789]{1}\\d{9}", "8853038949"));//true
System.out.println(Pattern.matches("[789]{1}\\d{9}", "3853038949"));//false (starts from 3)

}}

Java Regex 查找器示例

import java.util.regex.Pattern;
import java.util.Scanner;
import java.util.regex.Matcher;  
public class RegexExample8{  
    public static void main(String[] args){  
        Scanner sc=new Scanner(System.in);
        while (true) {  
        	System.out.println("Enter regex pattern:");
            Pattern pattern = Pattern.compile(sc.nextLine());  
            System.out.println("Enter text:");
            Matcher matcher = pattern.matcher(sc.nextLine());  
            boolean found = false;  
            while (matcher.find()) {  
                System.out.println("I found the text "+matcher.group()+" starting at index "+  
                 matcher.start()+" and ending at index "+matcher.end());  
                found = true;  
            }  
            if(!found){  
                System.out.println("No match found.");  
            }  
        }  
    }  
}  

输出

Enter regex pattern: java
Enter text: this is java, do you know java
I found the text java starting at index 8 and ending at index 12
I found the text java starting at index 26 and ending at index 30

让我们借助一个 Java 示例程序来详细了解 Java Regrex。

文件名： JavaRegrex.java

// Java program for demonstrating the features and functionalities of Java Regrex
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class JavaRegrex {

    public static void main(String[] args) {
        // Example 1: Matching a specific pattern
        System.out.println("Example 1: Matching a specific pattern");
        // Define the text in which to search
        String text1 = "The quick brown fox jumps over the lazy dog";
        // Define the pattern to match
        String pattern1 = "fox";
        // Check if the pattern matches the text using Pattern.matches()
        boolean matches1 = Pattern.matches(pattern1, text1);
        // Output whether the text contains the pattern
        System.out.println("Does the text contain the word 'fox'? " + matches1);

        // Example 2: Using Pattern and Matcher classes
        System.out.println("\nExample 2: Using Pattern and Matcher classes");
        // Define the text to search within
        String text2 = "Java is a programming language";
        // Define the regex pattern to match 3-letter words
        String regex2 = "\\b\\w{3}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern pattern2 = Pattern.compile(regex2);
        // Create a Matcher object to apply the pattern on the text
        Matcher matcher2 = pattern2.matcher(text2);
        // Find and output all matches found by iterating over Matcher's results
        System.out.print("3-letter words in the text: ");
        while (matcher2.find()) {
            System.out.print(matcher2.group() + " ");
        }
        System.out.println();

        // Example 3: Replacing matched patterns
        System.out.println("\nExample 3: Replacing matched patterns");
        // Define the text in which to search
        String text3 = "The cat sat on the mat";
        // Define the regex pattern to match the word 'cat'
        String regex3 = "\\bcat\\b";
        // Define the replacement string
        String replacement3 = "dog";
        // Replace all occurrences of 'cat' with 'dog' using String's replaceAll()
        // method
        String replacedText3 = text3.replaceAll(regex3, replacement3);
        // Output the original and replaced text
        System.out.println("Original text: " + text3);
        System.out.println("Replaced text: " + replacedText3);
        // Example 4: Splitting text using regex
        System.out.println("\nExample 4: Splitting text using regex");
        // Define the text to split
        String text4 = "apple,banana,orange,grape";
        // Define the regex pattern for splitting by comma
        String regex4 = ",";
        // Split the text using the regex pattern into an array of strings
        String[] parts4 = text4.split(regex4);
        // Output the split parts
        System.out.print("Fruits separated: ");
        for (String part : parts4) {
            System.out.print(part + " ");
        }
        System.out.println();
        // Example 5: Validating email addresses
        System.out.println("\nExample 5: Validating email addresses");
        // Define an array of email addresses to validate
        String[] emails = { "user@example.com", "invalid.email.com", "another.user@domain.co" };
        // Define the regex pattern for validating email addresses
        String emailRegex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
        // Compile the regex pattern into a Pattern object
        Pattern emailPattern = Pattern.compile(emailRegex);
        // Validate each email address by matching against the regex pattern
        System.out.println("Validating email addresses:");
        for (String email : emails) {
            // Create a Matcher object for each email
            Matcher emailMatcher = emailPattern.matcher(email);
            // Output the result of validation
            System.out.println(email + ": " + emailMatcher.matches());
        }
        // Example 6: Extracting domain names from URLs
        System.out.println("\nExample 6: Extracting domain names from URLs");
        // Define a URL
        String url = "https://www.example.com";
        // Define the regex pattern for extracting domain names from URLs
        String domainRegex = "^(https?://)?(www\\.)?([a-zA-Z0-9-]+\\.[a-z]{2,})";
        // Compile the regex pattern into a Pattern object
        Pattern domainPattern = Pattern.compile(domainRegex);
        // Create a Matcher object for the URL
        Matcher domainMatcher = domainPattern.matcher(url);
        // Find the domain name by matching against the regex pattern and output it
        if (domainMatcher.find()) {
            System.out.println("Domain extracted from URL: " + domainMatcher.group(3));
        }
    }
}

输出

Example 1: Matching a specific pattern
Does the text contain the word 'fox'? false

Example 2: Using Pattern and Matcher classes
3-letter words in the text:

Example 3: Replacing matched patterns
Original text: The cat sat on the mat
Replaced text: The dog sat on the mat

Example 4: Splitting text using regex
Fruits separated: apple banana orange grape

Example 5: Validating email addresses
Validating email addresses:
user@example.com: true
invalid.email.com: false
another.user@domain.co: true

Example 6: Extracting domain names from URLs
Domain extracted from URL: example.com

让我们看另一个例子，以详细了解 Java regrex。

文件名： RegexFeatures.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexFeatures {
    public static void main(String[] args) {
        // Example 1: Extracting phone numbers from text
        System.out.println("Example 1: Extracting phone numbers from text");
        // Define the text containing phone numbers
        String text1 = "Please call 123-456-7890 for assistance or 987-654-3210 for inquiries.";
        // Define the regex pattern to match phone numbers in the format xxx-xxx-xxxx
        String phoneRegex1 = "\\b\\d{3}-\\d{3}-\\d{4}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern phonePattern1 = Pattern.compile(phoneRegex1);
        // Create a Matcher object for the text
        Matcher phoneMatcher1 = phonePattern1.matcher(text1);
        // Find and output all matched phone numbers
        System.out.print("Phone numbers found in the text: ");
        while (phoneMatcher1.find()) {
            System.out.print(phoneMatcher1.group() + " ");
        }
        System.out.println();
        // Example 2: Extracting URLs from text
        System.out.println("\nExample 2: Extracting URLs from text");
        // Define the text containing URLs
        String text2 = "Visit our website at https://www.example.com or http://another.example.org";
        // Define the regex pattern to match URLs
        String urlRegex2 = "\\bhttps?://\\S+\\b";
        // Compile the regex pattern into a Pattern object
        Pattern urlPattern2 = Pattern.compile(urlRegex2);
        // Create a Matcher object for the text
        Matcher urlMatcher2 = urlPattern2.matcher(text2);
        // Find and output all matched URLs
        System.out.print("URLs found in the text: ");
        while (urlMatcher2.find()) {
            System.out.print(urlMatcher2.group() + " ");
        }
        System.out.println();

        // Example 3: Matching email addresses in text
        System.out.println("\nExample 3: Matching email addresses in text");
        // Define the text containing email addresses
        String text3 = "Contact us at email@example.com or another.email@example.org";
        // Define the regex pattern to match email addresses
        String emailRegex3 = "\\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern emailPattern3 = Pattern.compile(emailRegex3);
        // Create a Matcher object for the text
        Matcher emailMatcher3 = emailPattern3.matcher(text3);
        // Find and output all matched email addresses
        System.out.print("Email addresses found in the text: ");
        while (emailMatcher3.find()) {
            System.out.print(emailMatcher3.group() + " ");
        }
        System.out.println();

        // Example 4: Finding dates in text
        System.out.println("\nExample 4: Finding dates in text");
        // Define the text containing dates
        String text4 = "Important meetings on 2024-02-15 and 2024/02/20";
        // Define the regex pattern to match dates in the format yyyy-mm-dd or yyyy/mm/dd
        String dateRegex4 = "\\b\\d{4}[-/]\\d{2}[-/]\\d{2}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern datePattern4 = Pattern.compile(dateRegex4);
        // Create a Matcher object for the text
        Matcher dateMatcher4 = datePattern4.matcher(text4);
        // Find and output all matched dates
        System.out.print("Dates found in the text: ");
        while (dateMatcher4.find()) {
            System.out.print(dateMatcher4.group() + " ");
        }
        System.out.println();
    }
}

输出

Example 1: Extracting phone numbers from text
Phone numbers found in the text: 123-456-7890 987-654-3210 

Example 2: Extracting URLs from text
URLs found in the text: https://www.example.com http://another.example.org 

Example 3: Matching email addresses in text
Email addresses found in the text: email@example.com another.email@example.org 

Example 4: Finding dates in text
Dates found in the text: 2024-02-15 2024/02/20

总的来说，Java 中的正则表达式提供了一种灵活而强大的方式来处理字符串，允许您使用相对简单的模式执行复杂的匹配和操作操作。

Java 正则表达式选择题

1. 正则表达式模式 [a-zA-Z] 匹配什么？

任何单个小写字母
任何单个大写字母
任何单个字母（小写或大写）
任何单个数字

答案：C

解释：模式 [a-zA-Z] 匹配任何单个字符，该字符是小写或大写字母。

2. 哪个正则表达式模式匹配以 "Java" 开头的字符串？

^Java
Java$
Java.*
.*Java

答案：A

解释：^ 字符表示字符串的开头。因此，^Java 匹配以 "Java" 开头的任何字符串。

3. \d 在 Java 正则表达式中的作用是什么？

它匹配任何空白字符。
它匹配任何数字。
它匹配任何非数字字符。
它匹配任何字母字符。

答案：B

解释：正则表达式中的 \d 简写匹配任何数字字符，等效于 [0-9]。

4. 如何在 Java 正则表达式中表示空白字符？

\s
\w
\d
\b

答案：A

解释：正则表达式中的 \s 简写匹配任何空白字符，包括空格、制表符和换行符。

5. 哪个正则表达式模式匹配电子邮件地址？

\w+@\w+\.\w+
\d+@\d+\.\d+
\s+@\s+\.\s+
\W+@\W+\.\W+

答案：A

解释：模式 \w+@\w+\.\w+ 匹配一个简单的电子邮件地址结构，其中 \w+ 表示一个或多个单词字符，而 @ 和 . 是字面符号。

下一主题Java 异常处理

← 上一页下一页 →

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

关注我们

教程

Java 数据结构 C 语言 C++ 教程 C# 教程 PHP 教程 HTML 教程 JavaScript 教程 jQuery 教程 Spring 教程

面试题

Microsoft Amazon Adobe Intuit Accenture Cognizant Capgemini Wipro Tcs Infosys

在线编译器

C R C++ Php Java Html Swift Python JavaScript TypeScript

最新帖子 | 教程列表 | 隐私政策 | 关于我们 | 联系我们

© 版权所有 2011 - 2025 TpointTech.com。保留所有权利。