Java Basics Part 16/20 - Regular Expressions

Java Basics Part 16/20 - Regular Expressions

目录

Java Basics Part 1620 - Regular Expressions

目录

捕获组

正则表达式语法

Matcher 类方法
Index 方法

Study 方法

Replacement 方法

栗子
start 和 end

matches 和 lookingAt

replaceFirst 和 replaceAll

appendReplacement 和 appendTail

PatternSyntaxException 类的方法

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(): 22

matches() 和 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(): false

replaceFirst() 和 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():一堆错误信息，基本上是以上三者的汇总吧