Java Basics Part 16/20 - Regular Expressions
目录
Java 为正则表达式的模式匹配提供了 java.util.regex 包。
正则表达式主要用来匹配或者查询符合某个模式的字符串。
java.util.regex 包主要包含以下三个类：
- Pattern Class: 正则表达式编译后 产生 Pattern 对象。 Pattern 类没有构造器，为了产生一个 Pattern，必须调用 Pattern 的 compile() 方法，它会返回一个 Pattern 对象。Pattern 类的静态方法的第一个参数都是一个 正则表达式。
- Matcher Class: Matcher 对象是一个引擎，用来解释 pattern，并且在输入字符串上执行匹配操作。与 Pattern 类一样，Matcher 类也不提供构造器。可以 Pattern 对象的 matcher() 方法来获得一个 Matcher 对象。
- PatternSyntaxException: 用来指示 正则表达式 有语法错误的异常类。
捕获组
捕获组把多个字符当成一个整体。把多个字符放在一个括号中，就创建了一个捕获组。例如，正则表达式 (dog) 就创建了一个组，这个组里含有字母 d，o 和 g。
可以从左到右对左半边括号计数来得到捕获组的数目。例如，表达式 ((A)(B(C)))，有以下几个组：
- ((A)(B(C)))
- (A)
- (B(C))
- (C)
为了得到表达式中的捕获组数目，可以调用 matcher 对象的 groupCount() 方法。这个方法返回了一个 matcher 的 pattern 中含有的捕获组的数目。
还有一个特殊的组，group 0，这个组总是代表整个表达式。groupCount 不会对这个组进行计数。
举例：
下面这个例子演示了怎样在字符串中找到一个数字。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
public static void main( String args[] ){
// String to be scanned to find the pattern.
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
} else {
System.out.println("NO MATCH");
}
}
}
// output
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0可见，group 0 就是整个表达式。
正则表达式语法
下标列出了 Java 中所有可用的的正则表达式元字符。
| Subexpression | Matches |
|---|---|
| ^ | 一行的开头 |
| $ | 一行的结尾 |
| . | 任意字符除了换行符 |
| […] | 匹配中括号中的任一个字符 |
| [^…] | 匹配任意一个不在中括号中的字符 |
| \A | 整个字符串的开头 |
| \z | 整个字符串的结尾 |
| \Z | 整个字符串的结尾，除了行终止符 |
| re* | 匹配 0 或 多个前面的表达式 |
| re+ | 匹配 1 或 多个前面的表达式 |
| re? | 匹配 0 或 1 个前面的表达式 |
| re{n} | 匹配正好 n 个前面的表达式 |
| re{n,} | 匹配至少 n 个前面的表达式 |
| re{n,m} | 匹配最少 n 最多 m 个前面的表达式 |
| a|b | 匹配 a 或 b |
| (re) | 组表达式并记住匹配的文本 |
| (?:re) | 组表达式但是不记住匹配的文本 |
| (?> re) | 匹配单独的模式，不要反向追踪 |
| \w | 匹配单词字符 |
| \W | 匹配非单词字符 |
| \s | 匹配空白字符 [\t\b\r\f] |
| \S | 匹配非空白字符 |
| \d | 匹配数字 |
| \D | 匹配非数字 |
| \G | 最后一次匹配结束的匹配点 |
| \n | 反向引用第 n 个捕获组 |
| \b | 在中括号外是 匹配单词边界，中括号内是匹配 backspace |
| \B | 匹配非单词边界 |
| \n, \t, etc | 匹配 换行，tab 等 |
| \Q | 所有的字符都是普通字符，包括转义字符，直到遇到\E |
| \E | 与 \Q 对应 |
Matcher 类方法
Index 方法
Index 方法可以精确返回 匹配 出现在 输入中 的位置
| SN | Methods with Description |
|---|---|
| 1 | public int start():返回前一个匹配的开始位置 |
| 2 | public int start(int group)：返回匹配的组的开始的位置 |
| 3 | public int end()：返回匹配的最后一个字符之后的偏移 |
| 4 | public int end(int group)：返回匹配的组的最后一个字符之后的偏移 |
Study 方法
Study 方法查看输入字符串，并且返回一个 boolean，说明 pattern 是否能匹配。
| SN | Methods with Description |
|---|---|
| 1 | public boolean lookingAt():尝试使用 pattern 从起始位置匹配输入序列 |
| 2 | public boolean find()：尝试使用 pattern 匹配输入序列 |
| 3 | public boolean find(int start)：尝试从 start 处使用 pattern 匹配输入序列 |
| 4 | public boolean matches()：尝试使用 pattern 匹配整个输入序列 |
Replacement 方法
Replacement 方法主要用来替换字符串中的文本
| SN | Methods with Description |
|---|---|
| 1 | public Matcher appendReplacement(StringBuffer sb, String replacement)：把匹配的内容换成 replacement |
| 2 | public StringBuffer appendTail(StringBuffer sb)：剩下的没有匹配的全都添加到 sb 中 |
| 3 | public String replaceAll(String replacement) |
| 4 | public String replaceFirst(String replacement) |
| 5 | public static String quoteReplacement(String s) |
栗子
start() 和 end()
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "\\bcat\\b";
private static final String INPUT =
"cat cat cat cattie cat";
public static void main( String args[] ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // get a matcher object
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
// output
atch number 1
start(): 0
end(): 3
atch number 2
start(): 4
end(): 7
atch number 3
start(): 8
end(): 11
atch number 4
start(): 19
end(): 22matches() 和 lookingAt()
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ){
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}
// output
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): falsereplaceFirst() 和 replaceAll()
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " +
"All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
// output
The cat says meow. All cats say meow.appendReplacement() 和 appendTail()
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
// output
-foo-foo-foo-PatternSyntaxException 类的方法
PatternSyntaxException 用来表明正则表达式中的语法错误的。
| SN | Methods with Description |
|---|---|
| 1 | public String getDescription():返回错误描述 |
| 2 | public int getIndex()：返回错误号 |
| 3 | public String getPattern()：返回错误的正则表达式 |
| 4 | public String getMessage():一堆错误信息，基本上是以上三者的汇总吧 |