Java 正则表达式
<上一节
下一节>
Java中的java.util.regex包用于正则表达式的模式匹配。
一个正则表达式就是一个特定的字符序列，能够用来匹配、查找或者设置字符串，正则表达式使用特定的语法表示一个模式，也被用来进行搜索，编辑或处理文本和数据。
java.util.regex包主要包括以下三个类：
例如，正则表达式(dog) 创建了单一分组，组里包含"d"，"o"，和"g"。
捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：
((A)(B(C)))
(A)
(B(C))
(C)
可以通过调用matcher对象的groupCount方法来查看表达式有多少个分组。groupCount方法返回一个int值，表示matcher对象当前有多个捕获组。
还有一个特殊的组（组0），它总是代表整个表达式。该组不包括在groupCount的返回值中。
Start方法返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引，end方法最后一个匹配字符的索引加1。
这两个方法经常在输入字符串的开始使用。
我们通过下面这个例子，来解释这个功能：
下面的例子来解释这个功能：
看下面的例子来解释这个功能：
PatternSyntaxException 类提供了下面的方法来帮助我们查看发生了什么错误。
一个正则表达式就是一个特定的字符序列，能够用来匹配、查找或者设置字符串，正则表达式使用特定的语法表示一个模式，也被用来进行搜索，编辑或处理文本和数据。
java.util.regex包主要包括以下三个类：
- Pattern类：pattern对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个Pattern对象，你必须首先调用其公共静态编译方法，它返回一个Pattern对象。该方法接受一个正则表达式作为它的第一个参数。
- Matcher类：Matcher对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用Pattern对象的matcher方法来获得一个Matcher对象。
- PatternSyntaxException：PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
捕获组：
捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。例如，正则表达式(dog) 创建了单一分组，组里包含"d"，"o"，和"g"。
捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：
((A)(B(C)))
(A)
(B(C))
(C)
可以通过调用matcher对象的groupCount方法来查看表达式有多少个分组。groupCount方法返回一个int值，表示matcher对象当前有多个捕获组。
还有一个特殊的组（组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 places 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");
}
}
}
运行结果如下：Found value: This order was places for QT3000! OK? Found value: This order was places for QT300 Found value: 0
正则表达式语法：
下面是Java中所有正则表达式元字符的列表：| 子表达式 | 匹配 |
| ^ | 匹配开始行 |
| $ | 匹配结束行 |
| . | 匹配除换行外所有单个字符。使用m选项，允许它来匹配换行符。 |
| [...] | 匹配括号内任何单个字符。 |
| [^...] | 匹配不在括号内任何单个字符。 |
| A | 整个字符串的开头 |
| 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 | 匹配空白。等价于[ f]. |
| S | 匹配一个非空白。 |
| d | 匹配数字，等价于[0-9]。 |
| D | 匹配非数字。 |
| A | 匹配字符串的开始。 |
| 匹配字符串的结尾。如果存在一个换行符，只匹配换行符之前的。 | |
| z | 匹配字符串的结束。 |
| G | 匹配最后的匹配点。 |
| 返回捕获组编号“n”。 | |
| 匹配括号外的单词边界。匹配括号内的退格(0x08)。 | |
| B | 匹配非单词边界。 |
| , , etc. | 匹配换行，回车符，制表符等。 |
| Q | 跳过（引用）所有字符直到E。 |
| E | 结束Q开始的引用。 |
Mather类的方法：
索引方法：
索引方法提供了有用的索引值，精确表明输入字符串中在哪能找到匹配：| 序号 | 方法及说明 |
| 1 |
public int start() 返回以前匹配的初始索引。 |
| 2 |
public int start(int group) 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引 |
| 3 |
public int end() 返回最后匹配字符之后的偏移量。 |
| 4 |
public int end(int group) 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。 |
学习方法：
学习方法用来检查输入字符串并返回一个布尔值，表示是否找到该模式：| 序号 | 方法及说明 |
| 1 |
public boolean lookingAt() 尝试将从区域开头开始的输入序列与该模式匹配。 |
| 2 |
public boolean find() 尝试查找与该模式匹配的输入序列的下一个子序列。 |
| 3 |
public boolean find(int start） 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。 |
| 4 |
public boolean matches() 尝试将整个区域与模式匹配。 |
替换方法：
替换方法是替换输入字符串里文本的方法：| 序号 | 方法及说明 |
| 1 |
public Matcher appendReplacement(StringBuffer sb, String replacement) 实现非终端添加和替换步骤。 |
| 2 |
public StringBuffer appendTail(StringBuffer sb) 实现终端添加和替换步骤。 |
| 3 |
public String replaceAll(String replacement) 替换模式与给定替换字符串相匹配的输入序列的每个子序列。 |
| 4 |
public String replaceFirst(String replacement) 替换模式与给定替换字符串匹配的输入序列的第一个子序列。 |
| 5 |
public static String quoteReplacement(String s) 返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。 |
start 和end 方法：
下面是一个对单词“cat”出现在输入字符串中出现次数进行计数的例子：
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());
}
}
}
运行结果如下： Match number 1 start(): 0 end(): 3 Match number 2 start(): 4 end(): 7 Match number 3 start(): 8 end(): 11 Match number 4 start(): 19 end(): 22可以看到这个例子是使用单词边界，以确保字母 "c" "a" "t" 并非仅是一个较长的词的子串。它也提供了一些关于输入字符串中匹配发生位置的有用信息。
Start方法返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引，end方法最后一个匹配字符的索引加1。
matches 和lookingAt 方法：
matches 和lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是matcher要求整个序列都匹配，而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());
}
}
运行结果如下：Current REGEX is: foo Current INPUT is: fooooooooooooooooo lookingAt(): truematches(): false
replaceFirst 和replaceAll 方法：
replaceFirst 和replaceAll 方法用来替换匹配正则表达式的文本。不同的是，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);
}
}
运行结果如下：The cat says meow. All cats say meow.
appendReplacement 和appendTail 方法：
Matcher 类也提供了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());
}
}
运行结果如下：-foo-foo-foo-
PatternSyntaxException 类的方法：
PatternSyntaxException 是一个非强制异常类，它指示一个正则表达式模式中的语法错误。PatternSyntaxException 类提供了下面的方法来帮助我们查看发生了什么错误。
| 序号 | 方法及说明 |
| 1 |
public String getDescription() 获取错误的描述。 |
| 2 |
public int getIndex() 获取错误的索引。 |
| 3 |
public String getPattern() 获取错误的正则表达式模式。 |
| 4 |
public String getMessage() 返回多行字符串，包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示。 |
<上一节
下一节>
