java正则表达式

 

正则表达式是一种强大而灵活的文本处理工具。使用正则表达式，我们能够以编程的方式构造复杂的文本模式，并对输入的字符串进行搜索。

简单的来说，正则表达式就是以某种方式来描述字符串。

java从jdk1.4开始支持正则表达式。

 

一、简介

java.util.regex 是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。

它包括两个类：Pattern 和 Matcher

Pattern	正则表达式的编译表示形式
Matcher	通过解释 Pattern 对 character sequence 执行匹配操作的引擎。

 

 

指定为字符串的正则表达式必须首先被编译为Pattern的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

典型的调用模式：

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab")
boolean b = m.matches();

二、正则表达式的构造摘要

 

字符

x	字符 x
\\	反斜线字符
\0 n	带有八进制值 0 的字符 n (0 <=  n  <=  7)
\0 nn	带有八进制值 0 的字符 nn (0 <=  n  <=  7)
\0 mnn	带有八进制值 0 的字符 mnn （0 <=  m  <=  3、0 <=  n  <=  7）
\x hh	带有十六进制值 0x 的字符 hh
\u hhhh	带有十六进制值 0x 的字符 hhhh
\t	制表符 ('\u0009' )
\n	新行（换行）符 ('\u000A' )
\r	回车符 ('\u000D' )
\f	换页符 ('\u000C' )
\a	报警 (bell) 符 ('\u0007' )
\e	转义符 ('\u001B' )
\c x	对应于 x 的控制符

 

 

字符类

[abc]	a 、b 或 c （简单类）
[^abc]	任何字符，除了 a 、b 或 c （否定）
[a-zA-Z]	a 到 z 或 A 到 Z ，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p ：[a-dm-p] （并集）
[a-z&&[def]]	d 、e 或 f （交集）
[a-z&&[^bc]]	a 到 z ，除了 b 和 c ：[ad-z] （减去）
[a-z&&[^m-p]]	a 到 z ，而非 m 到 p ：[a-lq-z] （减去）

 

预定义字符类

.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]

 

边界匹配器

^	行的开头
$	行的结尾
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾
\Z	输入的结尾，仅用于最后的结束符（如果有的话）
\z	输入的结尾

 

Greedy 数量词
Reluctant 数量词
Possessive 数量词

X ?	X ，一次或一次也没有
X *	X ，零次或多次
X +	X ，一次或多次
X { n }	X ，恰好 n 次
X { n ,}	X ，至少 n 次
X { n , m }	X ，至少 n 次，但是不超过 m 次
X ??	X ，一次或一次也没有
X *?	X ，零次或多次
X +?	X ，一次或多次
X { n }?	X ，恰好 n 次
X { n ,}?	X ，至少 n 次
X { n , m }?	X ，至少 n 次，但是不超过 m 次
X ?+	X ，一次或一次也没有
X *+	X ，零次或多次
X ++	X ，一次或多次
X { n }+	X ，恰好 n 次
X { n ,}+	X ，至少 n 次
X { n , m }+	X ，至少 n 次，但是不超过 m 次

 

反斜线、转义和引用
反斜线字符 ('\') 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式 \\ 与单个反斜线匹配，而 \{ 与左括号匹配。

在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。

根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 "\b" 与单个退格字符匹配，而 "\\b" 与单词边界匹配。字符串字面值 "\(hello\)" 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 "\\(hello\\)"。

 

注意： java对反斜线\的处理与其他语言不同，在其他语言里\\表示“我想要在正则表达式中插入一个普通的反斜线，请不要给他任何特殊意义”，而在java中，\\的意思是“我要插入一个正则表达式的反斜线，所以后面的字符有特殊意义”。例如想要表达一个数字，那么正则表达式应该是 \\d, 普通的反斜线\\\\.

 

三、具体用法

 

Pattern 类 :

Pattern 的方法如下：

static Pattern	compile (String regex) 将给定的正则表达式编译并赋予给 Pattern 类
static Pattern	compile (String regex, int flags) 同上，但增加 flag 参数的指定，可选的 flag 参数包括：CASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ
int	flags () 返回当前 Pattern 的匹配 flag 参数 .
Matcher	matcher (CharSequence input) 生成一个给定命名的 Matcher 对象
static boolean	matches (String regex, CharSequence input) 编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配 , 该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生成一个 Matcher 实例。
String	pattern () 返回该 Patter 对象所编译的正则表达式。
String[]	split (CharSequence input) 将目标字符串按照 Pattern 里所包含的正则表达式为模进行分割。
String[]	split (CharSequence input, int limit) 作用同上，增加参数 limit 目的在于要指定分割的段数，如将 limi 设为 2，那么目标字符串将根据正则表达式分为割为两段。

一个正则表达式，也就是一串有特定意义的字符，必须首先要编译成为一个 Pattern 类的实例，这个 Pattern 对象将会使用 matcher() 方法来生成一个 Matcher 实例，接着便可以使用该 Matcher 实例以编译的正则表达式为基础对目标字符串进行匹配工作，多个 Matcher 是可以共用一个 Pattern 对象的。

现在我们先来看一个简单的例子，再通过分析它来了解怎样生成一个 Pattern 对象并且编译一个正则表达式，最后根据这个正则表达式将目标字符串进行分割：

import java.util.regex.*; 
 public class Replacement{ 
      public static void main(String[] args) throws Exception { 
        // 生成一个 Pattern, 同时编译一个正则表达式
        Pattern p = Pattern.compile("[/]+"); 
        // 用 Pattern 的 split() 方法把字符串按"/"分割
        String[] result = p.split( 
"Kevin has seen 《 LEON 》 seveal times,because it is a good film."
 +"/ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部"
 +"好电影。/ 名词 : 凯文。"); 
        for (int i=0; i<result.length; i++) 
            System.out.println(result[i]); 
      } 
 } 

 

输出结果为：

 Kevin has seen 《 LEON 》 seveal times,because it is a good film. 
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。
名词 : 凯文。

很明显，该程序将字符串按"/"进行了分段，我们以下再使用 split (CharSequence input, int limit) 方法来指定分段的段数，程序改动为：
tring[] result = p.split("Kevin has seen 《 LEON 》 seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/ 名词 : 凯文。"，2);

这里面的参数"2"表明将目标语句分为两段。

输出结果则为：

 Kevin has seen 《 LEON 》 seveal times,because it is a good film. 
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/ 名词 : 凯文。

 

 

---

Matcher 类 :

Matcher 方法如下：

Matcher	appendReplacement (StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个 StringBuffer 对象里。
StringBuffer	appendTail (StringBuffer sb) 将最后一次匹配工作后剩余的字符串添加到一个 StringBuffer 对象里。
int	end () 返回当前匹配的子串的最后一个字符在原目标字符串中的索引位置 。
int	end (int group) 返回与匹配模式里指定的组相匹配的子串最后一个字符的位置。
boolean	find () 尝试在目标字符串里查找下一个匹配子串。
boolean	find (int start) 重设 Matcher 对象，并且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串。
String	group () 返回当前查找而获得的与组匹配的所有子串内容
String	group (int group) 返回当前查找而获得的与指定的组匹配的子串内容
int	groupCount () 返回当前查找所获得的匹配组的数量。
boolean	lookingAt () 检测目标字符串是否以匹配的子串起始。
boolean	matches () 尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
Pattern	pattern () 返回该 Matcher 对象的现有匹配模式，也就是对应的 Pattern 对象。
String	replaceAll (String replacement) 将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。
String	replaceFirst (String replacement) 将目标字符串里第一个与既有模式相匹配的子串替换为指定的字符串。
Matcher	reset () 重设该 Matcher 对象。
Matcher	reset (CharSequence input) 重设该 Matcher 对象并且指定一个新的目标字符串。
int	start () 返回当前查找所获子串的开始字符在原目标字符串中的位置。
int	start (int group) 返回当前查找所获得的和指定组匹配的子串的第一个字符在原目标字符串中的位置。

（光看方法的解释是不是很不好理解？不要急，待会结合例子就比较容易明白了）

一个 Matcher 实例是被用来对目标字符串进行基于既有模式（也就是一个给定的 Pattern 所编译的正则表达式）进行匹配查找的，所有往 Matcher 的输入都是通过 CharSequence 接口提供的，这样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作。

我们分别来看看各方法的使用：

★ matches()/lookingAt ()/find()：
一个 Matcher 对象是由一个 Pattern 对象调用其 matcher() 方法而生成的，一旦该 Matcher 对象生成 , 它就可以进行三种不同的匹配查找操作：

1. matches() 方法尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
2. lookingAt () 方法将检测目标字符串是否以匹配的子串起始。
3. find() 方法尝试在目标字符串里查找下一个匹配子串。

以上三个方法都将返回一个布尔值来表明成功与否。

★ replaceAll ()/appendReplacement()/appendTail()：
Matcher 类同时提供了四个将匹配子串替换成指定字符串的方法：

1. replaceAll()
2. replaceFirst()
3. appendReplacement()
4. appendTail()

replaceAll() 与 replaceFirst() 的用法都比较简单，请看上面方法的解释。我们主要重点了解一下 appendReplacement() 和 appendTail() 方法。

appendReplacement(StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个 StringBuffer 对象里，而 appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个 StringBuffer 对象里。

例如，有字符串 fatcatfatcatfat, 假设既有正则表达式模式为"cat"，第一次匹配后调用 appendReplacement(sb,"dog"), 那么这时 StringBuffer sb 的内容为 fatdog，也就是 fatcat 中的 cat 被替换为 dog 并且与匹配子串前的内容加到 sb 里，而第二次匹配后调用 appendReplacement(sb,"dog")，那么 sb 的内容就变为 fatdogfatdog，如果最后再调用一次 appendTail（sb）, 那么 sb 最终的内容将是 fatdogfatdogfat。

还是有点模糊？那么我们来看个简单的程序：

 // 该例将把句子里的"Kelvin"改为"Kevin"
 import java.util.regex.*; 
 public class MatcherTest{ 
    public static void main(String[] args) 
                         throws Exception { 
        // 生成 Pattern 对象并且编译一个简单的正则表达式"Kelvin"
        Pattern p = Pattern.compile("Kevin"); 
        // 用 Pattern 类的 matcher() 方法生成一个 Matcher 对象
        Matcher m = p.matcher("Kelvin Li and Kelvin Chan are both working in " +
			"Kelvin Chen's KelvinSoftShop company"); 
        StringBuffer sb = new StringBuffer(); 
        int i=0; 
        // 使用 find() 方法查找第一个匹配的对象
        boolean result = m.find(); 
        // 使用循环将句子里所有的 kelvin 找出并替换再将内容加到 sb 里
        while(result) { 
            i++; 
            m.appendReplacement(sb, "Kevin"); 
            System.out.println("第"+i+"次匹配后 sb 的内容是："+sb); 
            // 继续查找下一个匹配对象
            result = m.find(); 
        } 
        // 最后调用 appendTail() 方法将最后一次匹配后的剩余字符串加到 sb 里；
        m.appendTail(sb); 
        System.out.println("调用 m.appendTail(sb) 后 sb 的最终内容是 :"+ 
			sb.toString());
    } 
 }
 

 

最终输出结果为：
第 1 次匹配后 sb 的内容是：Kevin
第 2 次匹配后 sb 的内容是：Kevin Li and Kevin
第 3 次匹配后 sb 的内容是：Kevin Li and Kevin Chan are both working in Kevin
第 4 次匹配后 sb 的内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's Kevin
调用 m.appendTail(sb) 后 sb 的最终内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's KevinSoftShop company.

看了上面这个例程是否对 appendReplacement()，appendTail() 两个方法的使用更清楚呢，如果还是不太肯定最好自己动手写几行代码测试一下。

★ group()/group(int group)/groupCount()：
下面代码将很好解释其用法：

import java.util.regex.*; 
 public class GroupTest{ 
    public static void main(String[] args) 
                         throws Exception { 
        Pattern p = Pattern.compile("(ca)(t)");        
        Matcher m = p.matcher("one cat,two cats in the yard"); 
        StringBuffer sb = new StringBuffer(); 
        boolean result = m.find(); 
        System.out.println("该次查找获得匹配组的数量为："+m.groupCount()); 
        for(int i=1;i<=m.groupCount();i++){ 
         System.out.println("第"+i+"组的子串内容为： "+m.group(i)); 
        } 
    } 
 }

 

输出为：
该次查找获得匹配组的数量为：2
第 1 组的子串内容为：ca
第 2 组的子串内容为：t

Matcher 对象的其他方法因比较好理解且由于篇幅有限，请读者自己编程验证。

 

参考：http://www.ibm.com/developerworks/cn/java/l-regp/part2/  Java中正则表达式的应用