【Java 常用类】java.util.regex包（1）Pattern、Matcher的常用方法

前言

我上一篇写了正则表达式的总结，这一篇讲一下Java中Pattern和Matcher类的使用。

正则表达式总结请移步：【正则表达式】（0）总结

Pattern

Pattern ：正则表达式的编译表示形式。

主要就是用来写正则表达式。

public final class Patternextends Object implements Serializable

---

Matcher 通过解释 Pattern 对 character sequence 执行匹配操作的引擎。

看名字也知道了，匹配器主要用来匹配。

public final class Matcher extends Object implements MatchResult

二、使用

1.字段（Pattern类）

int caseInsensitive = Pattern.CASE_INSENSITIVE; // 忽视大小写，使用Pattern的compile(String regex, int flags) 方法时使用。

2.构造器（Pattern类和Matcher类）

Pattern类和Matcher类都没有构造器。

Pattern类有静态方法，直接调用静态方法即可。

Matcher对象是通过Pattern类的matcher(CharSequence input) 进行创建的。可以看下面 3.5创建匹配器

3.常用方法（Pattern类）

3.1 创建正则编译到模式中

compile(String regex)
将给定的正则表达式编译到模式中。

也就是创建一个正则表达式。

private static Pattern c = Pattern.compile("[a-z]+"); // 创建正则表达式编译到模式中

3.2 创建正则编译到模式中并给定标志

compile(String regex, int flags)
将给定的正则表达式编译到具有给定标志的模式中。

也就是创建一个正则表达式。同时给定一个标志，如：忽视大小写。

private static Pattern c = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);

3.3 模式的字符串形式

toString()
返回匹配器的字符串表示形式。

返回模式的字符串形式，也就是正则。

/** 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度 */
private static Pattern p = Pattern.compile("[a-z]+");	
public static void main(String[] args) {
    String s = p.toString();
    System.out.println(s); // [a-z]+
}

3.4 字符串匹配

matches(String regex, CharSequence input)
编译给定正则表达式并尝试将给定输入与其匹配。

就是给一个字符串形式的正则表达式，同时给一个需要判断是否匹配的字符串。匹配时返回true，不匹配返回false

boolean m = Pattern.matches("[a-z]+", "hello");
System.out.println(m); // true
boolean m2 = Pattern.matches("[a-z]+", "123");
System.out.println(m2); // false

3.5 创建匹配器

matcher(CharSequence input)
创建匹配给定输入与此模式的匹配器。

创建一个匹配器，同时给定需要匹配器匹配的字符。

/** 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度 */
private static Pattern p = Pattern.compile("[a-z]+");
public static void main(String[] args) {
    Matcher hello = p.matcher("hello"); // 获取到一个匹配器
}

4.常用方法（Matcher类）

4.1 字符串匹配

matches()
尝试将整个区域与模式匹配。

同上面 3.1 字符串匹配 一样。
只不过3.1调用的是Pattern的静态方法matches()，而这里调用的是Matcher对象的matches方法。

/** 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度 */
private static Pattern p = Pattern.compile("[a-z]+");
public static void main(String[] args) {
	Matcher matcher = p.matcher("hello");
	boolean m = matcher.matches();
	System.out.println(m); // true

	Matcher matcher2 = p.matcher("hello 123");
	boolean m2 = matcher2.matches();
	System.out.println(m2); // false
}

4.2 捕获组数量

group(int group)
返回此匹配器模式中的捕获组数。

正则表达式中，正则表达式会左侧开始，每出现一个左括号"("记做第1个组，以此类推。

	private static Pattern p = Pattern.compile("(([a-z]).)");
    public static void main(String[] args) {
        Matcher matcher = p.matcher("a-b-c-d-e-");
        int count = matcher.groupCount();
        System.out.println(count);
    }

4.3 正则替换

replaceFirst(String replacement)
替换第一个匹配的字符串
replaceAll(String replacement)
替换所有匹配的字符串

	private static Pattern p = Pattern.compile("(([a-z]).)");
    public static void main(String[] args) {
        Matcher matcher = p.matcher("a-b-c-d-e-");
        String s = matcher.replaceFirst("z-"); // 替换第一个匹配的字符串
        System.out.println(s); // z-b-c-d-e-
        String all = matcher.replaceAll("z-"); // 替换所有匹配的字符串
        System.out.println(all); // z-z-z-z-z-
    }

4.4 查找获取匹配

find()
尝试查找与该模式匹配的输入序列的下一个子序列。

尝试匹配下一个匹配的字符串，就是查找字符串中匹配的子字符串

group()
返回由以前匹配操作所匹配的输入子序列。

返回之前匹配的子字符串，就是获取字符串中匹配的子字符串

    /** 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度 */
    private static Pattern p = Pattern.compile("[a-z].");

    public static void main(String[] args) {
        Matcher matcher = p.matcher("a-b-c-d-e-");
        // 一个个匹配
        boolean f = matcher.find(); // true
        String g = matcher.group(); // a-
        System.out.println("是否有匹配的子字符串："+f+"\n匹配的结果为："+g);

        // 循环匹配，查找剩下的捕获组
        while (matcher.find()) {
            String group = matcher.group();
            System.out.println(group);
        }
    }

相关

更多常用类请查看：【Java SE 常用类】目录