Detailed explanation and usage: Java regular expression analysis

Detailed explanation and usage of Java regular expressions

Regular Expression (Regular Expression) is a powerful text processing tool that can be found in various programming languages. Wide range of applications. In Java, we can use regular expressions to achieve string matching, replacement, splitting and other operations. This article will introduce the use of Java regular expressions in detail and give specific code examples.

1. Regular expression syntax

Java's regular expression syntax is consistent with the standard regular expression syntax. The following are some commonly used regular expression metacharacters and their meanings:

• d: Matches any number.
• D: Matches any non-numeric character.
• w: Match any letter, number or underscore.
• W: Matches any non-letter, number or underscore character.
• s: Matches any whitespace character, including spaces, tabs, newlines, etc.
• S: Matches any non-whitespace character.
• : Matches a word boundary.
• ^: Match the beginning of the string.
• $: Matches the end position of the string.
• .: Match any character.
• *: Matches zero or more preceding elements.
• : Matches one or more preceding elements.
• ?: Match zero or one previous element.
• {n}: Match the previous element exactly n times.
• {n,}: Match the previous element at least n times.
• {n,m}: Match the previous element at least n times and at most m times.
• [...]: Matches any character in the square brackets.
• ¹: Matches any character except the characters in square brackets.

There are many other metacharacters and grammatical rules that can be used flexibly according to specific needs.

2. Pattern class

In Java, the Pattern class is a compiled representation of a regular expression. We can compile the regular expression string and generate a Pattern object through the static method compile() provided by the Pattern class. For example:

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

3. Matcher class

The Matcher class is the engine for all regular expression matching operations. We can create a Matcher object through the matcher() method of the Pattern object.

• matches()Method: used to test whether the regular expression matches the entire string. For example:

String regex = "hello";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("hello world");
boolean matched = matcher.matches();
System.out.println(matched); // 输出：true

• find()Method: Used to find subsequences in a string that match a regular expression. For example:

String regex = "\d+";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("abc123def");
while (matcher.find()) {
    System.out.println(matcher.group());
}

The output result of the above code is:

123

• replaceAll() method: used to replace strings that match regular expressions part. For example:

String regex = "\btom\b";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("I love tom and tom loves me");
String result = matcher.replaceAll("Jerry");
System.out.println(result); // 输出：I love Jerry and Jerry loves me

4. Specific examples

The following are some common scenarios for using regular expressions and corresponding code examples:

• Verify whether the mobile phone number is legal:

String regex = "^1[3-9]\d{9}$";
Pattern pattern = Pattern.compile(regex);
String phone = "13612345678";
boolean isValid = pattern.matcher(phone).matches();
System.out.println(isValid); // 输出：true

• Extract the link in the HTML text:

String regex = "<a\s.*?href="([^"]+)".*?>";
Pattern pattern = Pattern.compile(regex);
String html = "<a href="http://www.example.com">Example</a>";
Matcher matcher = pattern.matcher(html);
while (matcher.find()) {
    System.out.println(matcher.group(1));
}

The output result of the above code is:

http://www.example.com

• Split the string into a word list:

String regex = "\b\w+\b";
Pattern pattern = Pattern.compile(regex);
String text = "Hello world, I love Java!";
Matcher matcher = pattern.matcher(text);
List<String> words = new ArrayList<>();
while (matcher.find()) {
    words.add(matcher.group());
}
System.out.println(words);

The output result of the above code is:

[Hello, world, I, love, Java]

Summary:
This article details the use of Java regular expressions methods, and specific code examples are given. By learning the syntax of regular expressions and the usage of the Pattern and Matcher classes, we can flexibly use regular expressions to process strings. I hope this article can help you understand and use Java regular expressions.

1. ... ↩

The above is the detailed content of Detailed explanation and usage: Java regular expression analysis. For more information, please follow other related articles on the PHP Chinese website!