关于正则表达式:JAVA中正则表达式的应用－javautilregex篇

当初 JDK1.4 里有了本人的正则表达式 API 包，JAVA 程序员能够免去找第三方提供的正则表达式库的周折了，咱们当初就马上来理解一下这个 SUN 提供的迟来恩物 - - 对我来说的确如此。

1. 简介：

java.util.regex 是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。
它包含两个类：Pattern和 Matcher
一个 Pattern 是一个正则表达式经编译后的体现模式。
一个 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; 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)办法来指定分段的段数，程序改变为：

String[] 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 www.kevin@163.net

那么输入后果将会是：EMAIL 地址不能以 ’www.’ 起始

如果输出的 EMAIL 为 @kevin@163.net

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

当输出为：cgjmail#$%@163.net

那么输入就是：

输出的 EMAIL 地址里蕴含有冒号、逗号等非法字符，请批改
您当初的输出为: cgjmail#$%@163.net
批改后非法的地址应相似: cgjmail@163.net

5．总结：

本文介绍了 jdk1.4.0-beta3 里正则表达式库 –java.util.regex 中的类以及其办法，如果联合与上一篇中所介绍的 Jakarta-ORO API 作比拟，读者会更容易把握该 API 的应用，当然该库的性能将在将来的日子里一直扩大，心愿取得最新信息的读者最好到及时到 SUN 的网站去理解。

6．结束语：

原本打算再多写一篇介绍一下需付费的正则表达式库中较具代表性的作品，但感觉既然有了 xx 且优良的正则表达式库能够应用，何必还要去找需付费的呢，置信很多读者也是这么想的:，所以有趣味理解更多其余的第三方正则表达式库的敌人能够本人到网上查找或者到我在参考资料里提供的网址去看看。