Java 正则表达式的使用

java.util.regex 包主要包括以下三个类：

Pattern 类：

　　pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher 类：

　　Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

PatternSyntaxException：

　　PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

　　以下实例中使用了正则表达式.*runoob.*用于查找字符串中是否包含了runoob子串：

package cc.bcy;

import java.util.regex.*;

public class RegexExample 
{
    public static void main(String[] args) 
    {
        String content="I am noob from runoob.com";
        String pattern=".*runoob.*";
        boolean isMatch=Pattern.matches(pattern, content);
        System.out.println("字符串中是否包含了‘runoob’子字符串？"+isMatch);
    }
}
/*
字符串中是否包含了‘runoob’子字符串？true
*/

捕获组：

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。可以通过调用 matcher 对象的groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。

还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

package cc.bcy;

import java.util.regex.*;

public class RegexExample 
{
    public static void main(String[] args) 
    {
        String line="This order was placed for QT3000! OK?";
        String pattern="(\\D*)(\\d+)(.*)";
        //创建Pattern对象
        Pattern p=Pattern.compile(pattern);
        //创建Matcher对象
        Matcher m=p.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));
            System.out.println("Found value: "+m.group(3));
        }
        else
        {
            System.out.println("No Match!");
        }
        int n=m.groupCount();
        System.out.println("一共有"+n+"个捕获组");
    }
}
/*
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?
一共有3个捕获组
*/

Java 正则表达式语法：

　　在其他语言中，\\ 表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。

　　在 Java 中，\\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。

　　所以，在其他的语言中（如Perl），一个反斜杠 \ 就足以具有转义的作用，而在 Java 中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在 Java 的正则表达式中，两个 \\ 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 \\d，而表示一个普通的反斜杠是。

Matcher 类的方法：

下面是一个对单词 "cat" 出现在输入字符串中出现次数进行计数的例子：

package cc.bcy;

import java.util.regex.*;

public class RegexExample 
{
    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);
        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());
            System.out.println();
        }
    }
}
/*
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
*/

matches 和 lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是 matches 要求整个序列都匹配，而lookingAt 不要求。lookingAt 方法虽然不需要整句都匹配，但是需要从第一个字符开始匹配。

把字符串中的匹配项全部替换成“-”：（用appendReplacement()方法）

package cc.bcy;

import java.util.regex.*;

public class RegexExample 
{
    private static final String REGEX="a*b";
    private static final String INPUT="aabfooaabfooabfoobkkk";
    public static void main(String[] args) 
    {
        Pattern p=Pattern.compile(REGEX);
        Matcher m=p.matcher(INPUT);
        StringBuffer sb=new StringBuffer();
        while(m.find())
        {
            m.appendReplacement(sb, "-");
        }
        m.appendTail(sb);
        System.out.println(sb.toString());
    }
}
/*
-foo-foo-foo-kkk
*/

replaceFirst 和 replaceAll 方法用来替换匹配正则表达式的文本。不同的是，replaceFirst 替换首次匹配，replaceAll 替换所有匹配。

package cc.bcy;

import java.util.regex.*;

public class RegexExample 
{
    private static final String REGEX="dog";
    private static final String INPUT="The dog says meow. All dogs say meow.";
    public static void main(String[] args) 
    {
        Pattern p=Pattern.compile(REGEX);
        Matcher m=p.matcher(INPUT);
        String str=m.replaceAll("cat");
        System.out.println(str);
    }
}
/*
The cat says meow. All cats say meow.
*/

PatternSyntaxException 类的方法：

　　PatternSyntaxException 是一个非强制异常类，它指示一个正则表达式模式中的语法错误。 PatternSyntaxException 类提供了下面的方法来帮助我们查看发生了什么错误。

Java 正则表达式的使用

猜你喜欢