java正则表达式

现在JDK1.4里终于有了自己的正则表达式API包，JAVA程序员可以免去找第三方提供的正则表达式库的周折了，我们现在就马上来了解一下这个SUN提供的迟来恩物- -对我来说确实如此。 
1.简介：  
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。 

它包括两个类：Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式。  
Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。 

以下我们就分别来看看这两个类： 

2.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; iSystem.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. 
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。 

由上面的例子，我们可以比较出java.util.regex包在构造Pattern对象以及编译指定的正则表达式的实现手法与我们在上一篇中所介绍的Jakarta-ORO 包在完成同样工作时的差别，Jakarta-ORO 包要先构造一个PatternCompiler类对象接着生成一个Pattern对象，再将正则表达式用该PatternCompiler类的compile()方法来将所需的正则表达式编译赋予Pattern类： 

PatternCompiler orocom=new Perl5Compiler(); 

Pattern pattern=orocom.compile("REGULAR EXPRESSIONS"); 

PatternMatcher matcher=new Perl5Matcher(); 

但是在java.util.regex包里，我们仅需生成一个Pattern类，直接使用它的compile()方法就可以达到同样的效果: 
Pattern p = Pattern.compile("[/]+"); 

因此似乎java.util.regex的构造法比Jakarta-ORO更为简洁并容易理解。 

3.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对象生成,它就可以进行三种不同的匹配查找操作： 

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

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

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

replaceAll() 
replaceFirst() 
appendReplacement() 
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()： 
该系列方法与我们在上篇介绍的Jakarta-ORO中的MatchResult .group()方法类似(有关Jakarta-ORO请参考上篇的内容)，都是要返回与组匹配的子串内容，下面代码将很好解释其用法： 
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对象的其他方法因比较好理解且由于篇幅有限，请读者自己编程验证。 

4．一个检验Email地址的小程序： 
最后我们来看一个检验Email地址的例程，该程序是用来检验一个输入的EMAIL地址里所包含的字符是否合法，虽然这不是一个完整的EMAIL地址检验程序，它不能检验所有可能出现的情况，但在必要时您可以在其基础上增加所需功能。 
import java.util.regex.*; 
public class Email { 
public static void main(String[] args) throws Exception { 
String input = args[0]; 
//检测输入的EMAIL地址是否以 非法符号"."或"@"作为起始字符 
Pattern p = Pattern.compile("^\\.|^\\@"); 
Matcher m = p.matcher(input); 
if (m.find()){ 
System.err.println("EMAIL地址不能以'.'或'@'作为起始字符"); 
} 
//检测是否以"www."为起始 
p = Pattern.compile("^www\\."); 
m = p.matcher(input); 
if (m.find()) { 
System.out.println("EMAIL地址不能以'www.'起始"); 
} 
//检测是否包含非法字符 
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+"); 
m = p.matcher(input); 
StringBuffer sb = new StringBuffer(); 
boolean result = m.find(); 
boolean deletedIllegalChars = false; 
while(result) { 
//如果找到了非法字符那么就设下标记 
deletedIllegalChars = true; 
//如果里面包含非法字符如冒号双引号等，那么就把他们消去，加到SB里面 
m.appendReplacement(sb, ""); 
result = m.find(); 
} 
m.appendTail(sb); 
input = sb.toString(); 
if (deletedIllegalChars) { 
System.out.println("输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改"); 
System.out.println("您现在的输入为: "+args[0]); 
System.out.println("修改后合法的地址应类似: "+input); 
} 
} 
} 



例如，我们在命令行输入：java Email 

那么输出结果将会是：EMAIL地址不能以'www.'起始 

如果输入的EMAIL为@[e-mail] 

则输出为：EMAIL地址不能以'.'或'@'作为起始字符 

当输入为：cgjmail#$[e-mail] 

那么输出就是： 

输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改 
您现在的输入为: cgjmail#$[e-mail] 
修改后合法的地址应类似: [e-mail] 

5．总结： 
本文介绍了jdk1.4.0-beta3里正则表达式库--java.util.regex中的类以及其方法，如果结合与上一篇中所介绍的Jakarta-ORO API作比较，读者会更容易掌握该API的使用，当然该库的性能将在未来的日子里不断扩展，希望获得最新信息的读者最好到及时到SUN的网站去了解。 

6．结束语： 
本来计划再多写一篇介绍一下需付费的正则表达式库中较具代表性的作品，但觉得既然有了免费且优秀的正则表达式库可以使用，何必还要去找需付费的呢，相信很多读者也是这么想的:，所以有兴趣了解更多其他的第三方正则表达式库的朋友可以自己到网上查找或者到我在参考资料里提供的网址去看看。 

参考资料 

java.util.regex的帮助文档 
Dana Nourie 和Mike McCloskey所写的Regular Expressions and the Java™ Programming Language 
需要更多的第三方正则表达式资源以及基于它们所开发的应用程序请看 

Java's java.util.regex 包包括：Pattern类、Matcher类、MatchResult接口和PatternSyntaxException异常：

• Pattern 对象代表了编译了的正则表达式（A compiled representation of a regular expression.）。
• Matcher ，An engine that performs match operations on a character sequence by interpreting a Pattern.
• MatchResult接口：The result of a match operation.
• PatternSyntaxException对象，描述非法的regex patterns，Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.

 同时还需要了解是CharSequence，JDK 1.4定义的新的接口，它提供了String和StringBuffer这两个类的字符序列的抽象

interface CharSequence {
  charAt(int i);
  length();
  subSequence(int start, int end);
  toString();
}

为了实现这个新的CharSequence接口，String，StringBuffer以及CharBuffer都作了修改，很多的正则表达式的操作都要拿CharSequence作参数。

Matcher类的几个重要的方法：

• boolean matches()：Pattern匹配整个字符串
• boolean lookingAt()：Pattern匹配字符串的开头
• boolean find()：发现CharSequence里的，与pattern相匹配的多个字符序列
  boolean find(int start)：告诉方法从参数start位置开始查找

group的概念

Group是指里用括号括起来的，能被后面的表达式调用的正则表达式。

Group 0 表示整个表达式，group 1表示第一个被括起来的group，以此类推。所以；

A(B(C))D

里面有三个group：group 0是ABCD， group 1是BC，group 2是C。

你可以用下述Matcher方法来使用group：

• public int groupCount( )返回matcher对象中的group的数目。不包括group0。
• public String group( ) 返回上次匹配操作(比方说find( ))的group 0(整个匹配)
• public String group(int i)返回上次匹配操作的某个group。如果匹配成功，但是没能找到group，则返回null。
• public int start(int group)返回上次匹配所找到的group的开始位置。
• public int end(int group)返回上次匹配所找到的group的结束位置，最后一个字符的下标加一。
• split( ) 是指将以正则表达式为界，将字符串分割成String数组,如果带有limit参数，split( )会限定分割的次数。
• replaceFirst(String replacement)将字符串里，第一个与模式相匹配的子串替换成replacement。
• replaceAll(String replacement)，将输入字符串里所有与模式相匹配的子串全部替换成replacement。
• appendReplacement(StringBuffer sbuf, String replacement)对sbuf进行逐次替换，而不是像replaceFirst( )或replaceAll( )那样，只替换第一个或全部子串。这是个非常重要的方法，因为replacement(replaceFirst( )和replaceAll( )只允许用固定的字符串来充当replacement)。有了这个方法，你就可以编程区分group，从而实现更强大的替换功能。
• 调用完appendReplacement( )之后，为了把剩余的字符串拷贝回去，必须调用appendTail(StringBuffer sbuf, String replacement)。

 

使用group可以做到逐步缩小匹配的范围，直至精确匹配的目的。

start( )和end( )：如果匹配成功，start( )会返回此次匹配的开始位置，end( )会返回此次匹配的结束位置，即最后一个字符的下标加一。如果之前的匹配不成功(或者没匹配)，那么无论是调用start( )还是end( )，都会引发一个IllegalStateException。

二、4大使用方法：

查询

String str="abc efg ABC";

String regEx="a|f"; //表示a或f

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher(str);

boolean rs=m.find();

如果str中有regEx，那么rs为true，否则为flase。如果想在查找时忽略大小写，则可以写成Pattern p=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);

提取

String regEx=".+\(.+)$";

String str="c:\dir1\dir2\name.txt";

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher(str);

boolean rs=m.find();

for(int i=1;i<=m.groupCount();i++){

System.out.println(m.group(i));

}

以上的执行结果为name.txt，提取的字符串储存在m.group(i)中，其中i最大值为m.groupCount();

 

分割

String regEx="::";

Pattern p=Pattern.compile(regEx);

String[] r=p.split("xd::abc::cde");

执行后，r就是{"xd","abc","cde"}，其实分割时还有跟简单的方法：

String str="xd::abc::cde";

String[] r=str.split("::");

 

替换或者删除

String regEx="a+"; //表示一个或多个a

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher("aaabbced a ccdeaa");

String s=m.replaceAll("A");

　　结果为"Abbced A ccdeA"

　　如果写成空串，既可达到删除的功能，比如：

String s=m.replaceAll("");

　　结果为"bbced ccde"

 

三、一个实际的例子

下面的函数是一个实际应用的例子，需求是需要将抓取的网页中的 中的地址，保存到一个地址列表中（以供抓取图片使用），并将绝对地址替换成本地的相对地址，即。

public static Map getImagesURL(String description) {

      Map map = new HashMap();
        // img 的正则表达式:匹配标签       
        String imgPattern = "<\\s*img\\s+([^>]+)\\s*>";
        Pattern pattern1 = Pattern.compile(imgPattern, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern1.matcher(description);

        // img src元素的正则表达式：匹配img标签内的src属性
        String srcPattern = "\\s*src\\s*=\\s*\"([^\"]+)\\s*\"";
        Pattern pattern2 = Pattern.compile(srcPattern, Pattern.CASE_INSENSITIVE);

        while (matcher.find()) {

           //group()返回符合表达式的内容
            Matcher matcher2 = pattern2 .matcher(matcher.group());
            // 一定要find(),这是实际的匹配动作
            if (matcher2.find()) {
                String src = matcher2.group();
                log.info(src);
                int i2 = src.lastIndexOf('/');
                int i1 = src.indexOf("http");
                if (i1 != -1) {
                    map.put(src.substring(i2 + 1, src.length() - 1), src
                            .substring(i1, src.length() - 1));
                }
            }
        }
        log.debug("图片：" + map);
        return map;
    }

 

整体思路是先匹配到img标签，然后匹配src属性，并修改src的属性

"<\\s*img\\s+([^>]+)\\s*>" 的解释：

* :0 或多个空格   +: 至少一个空格

([^>]+)：指的是到>为止的所有的元素，至少一个

 

常用的正则表达式（参考jdk的regex文档）

字符集类

.                            表示任意一个字符

[abc]                     表示字符a，b，c中的任意一个(与a|b|c相同)

[^abc]                   除a，b，c之外的任意一个字符(否定)

[a-zA-Z]                从a到z或A到Z当中的任意一个字符(范围)

[abc[hij]]              a,b,c,h,i,j中的任意一个字符(与a|b|c|h|i|j相同)(并集)

[a-z&&[hij]]          h,i,j中的一个(交集)

\s                          空格字符(空格键, tab, 换行, 换页, 回车)

\S                         非空格字符([^\s])

\d                         一个数字，也就是[0-9]

\D                         一个非数字的字符，也就是[^0-9]

\w                        一个单词字符(word character)，即[a-zA-Z_0-9]

\W                       一个非单词的字符，[^\w]

字符类：

B                         字符B

\xhh                    16进制值0xhh所表示的字符

\uhhhh                16进制值0xhhhh所表示的Unicode字符

\t                         Tab

\n                        换行符

\r                         回车符

\f                        换页符

\e                       Escape

逻辑运算符

XY                      X 后面跟着 Y

X|Y                    X或Y

(X)                     一个"要匹配的组(capturing group)". 以后可以用\i来表示第i个被匹配的组。

边界匹配符

^                      一行的开始

$                      一行的结尾

\b                    一个单词的边界

\B                    一个非单词的边界

\G                   前一个匹配的结束

数量表示符

"数量表示符(quantifier)"的作用是定义模式应该匹配多少个字符。

• Greedy(贪婪的)： 除非另有表示，否则数量表示符都是greedy的。Greedy的表达式会一直匹配下去，直到匹配不下去为止。(如果你发现表达式匹配的结果与预期的不符)，很有可能是因为，你以为表达式会只匹配前面几个字符，而实际上它是greedy的，因此会一直匹配下去。
• Reluctant(勉强的)： 用问号表示，它会匹配最少的字符。也称为lazy, minimal matching, non-greedy, 或ungreedy。
• Possessive(占有的)： 目前只有Java支持(其它语言都不支持)。它更加先进，所以你可能还不太会用。用正则表达式匹配字符串的时候会产生很多中间状态，(一般的匹配引擎会保存这种中间状态，)这样匹配失败的时候就能原路返回了。占有型的表达式不保存这种中间状态，因此也就不会回头重来了。它能防止正则表达式的失控，同时也能提高运行的效率。

Greedy                    Reluctant                           Possessive                      匹配

X?                            X??                                      X?+                                  匹配一个或零个X

X*                            X*?                                      X*+                                  匹配零或多个X

X+                           X+?                                      X++                                 匹配一个或多个X

X{n}                        X{n}?                                   X{n}+                               匹配正好n个X

X{n,}                       X{n,}?                                 X{n,}+                              匹配至少n个X

X{n,m}                   X{n,m}?                                X{n,m}+                           匹配至少n个，至多m个X

参考资料

要想进一步学习正则表达式，建议看Mastering Regular Expression, 2nd Edition，作者Jeffrey E. F. Friedl (O’Reilly, 2002)。

"Regular Expressions and the Java Programming Language," Dana Nourie and Mike McCloskey (Sun Microsystems, August 2002) presents a brief overview of java.util.regex, including five illustrative regex-based applications:
http://developer.java.sun.com/developer/technicalArticles/releases/1.4regex/

http://www.blogjava.net/beike/archive/2006/04/28/43832.html