Pattern 类方法应用

Pattern 类是正则表达式的编译表示形式。字符串形式的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 

Pattern 类提供了如下方法：

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

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

• int flags() 返回此模式的匹配标志

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

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

• String pattern() 返回在其中编译过此模式的正则表达式

• static String quote(String s) 返回指定 String 的字面值模式 String

• String[] split(CharSequence input) 围绕此模式的匹配拆分给定输入序列

• String[] split(CharSequence input, int limit) 围绕此模式的匹配拆分给定输入序列

• String toString() 返回此模式的字符串表示形式

compile 方法

在 Pattern 类中，提供了两个 compile 静态方法，使用该方法可以将正则表达式字符串编译成 Pattern 实例。其中，拥有两个参数的 compile 方法接受一个匹配标志。匹配标志可包括：CASE_INSENSITIVE、MULTILINE、DOTALL、UNICODE_CASE、 CANON_EQ、UNIX_LINES、LITERAL 和 COMMENTS。例如：忽略大小写标志 CASE_INSENSITIVE、多行匹配模式 MULTILINE。

实例：使用 Pattern 的 compile 方法匹配文本 “hello world”，且不区分大小写。

import java.util.regex.Pattern;

public class Demo4 {

    public static void main(String[] args) {
        // Pattern.CASE_INSENSITIVE 表示忽略大小写
        Pattern pattern = Pattern.compile("(hello)( )(world)", Pattern.CASE_INSENSITIVE);
        System.out.println(pattern.matcher("hello world").matches());
        System.out.println(pattern.matcher("HELLO WORLD").matches());
        System.out.println(pattern.matcher("Hello World").matches());
    }

}

运行结果如下：

true
true
true

正则表达式广告位

flags 方法

该方法将返回编译此模式时指定的匹配标志。如下：

import java.util.regex.Pattern;

public class Demo5 {

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(hello)( )(world)", Pattern.CASE_INSENSITIVE);
        int flag = pattern.flags();
        if(flag == Pattern.CASE_INSENSITIVE) {
            System.out.println("忽略大小写");
        } else {
            System.out.println("匹配大小写");
        }
    }

}

运行结果如下：

忽略大小写

matcher 方法

根据输入的文本和 Pattern 模式创建一个匹配器 Matcher。用法如下：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo6 {

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(hello)( )(world)");
        Matcher matcher = pattern.matcher("hello world");
        System.out.println(matcher);
    }

}

运行结果如下：

java.util.regex.Matcher[pattern=(hello)( )(world) region=0,11 lastmatch=]

matches 方法

matches 静态方法是 Pattern 类提供的便捷方法。该方法将编译给定正则表达式并尝试与给定的输入文本进行匹配。 

调用此便捷方法的形式：

Pattern.matches(regex, input);

与表达式 

Pattern.compile(regex).matcher(input).matches()

的行为完全相同。 

注意：如果 Pattern 模式需要重用，编译一次后重用此模式比每次都调用 matches 此方法效率更高。

参数说明：

• regex - 要编译的表达式

• input - 要匹配的字符序列 

实例：使用 Pattern 的 matches 静态方法匹配文本 “hello world”。

import java.util.regex.Pattern;

public class Demo7 {

    public static void main(String[] args) {
        boolean flag = Pattern.matches(
                "(hello)( )(world)", "hello world");
        System.out.println("flag = " + flag);
    }

}

运行结果如下：

flag = true

pattern 方法

该方法将返回当前 Pattern 调用 compile 时指定的正则表达式。用法如下：

import java.util.regex.Pattern;

public class Demo8 {

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(hello)( )(world)");
        System.out.println(pattern.pattern());
    }

}

运行结果如下：

(hello)( )(world)

quote 方法

该静态方法将返回指定 String 的字面值模式 String。此方法返回一个 String，可以将其用于创建与该方法参数匹配的 Pattern，就好像它是字面值模式一样。

注意：输入序列中的元字符和转义序列不具有任何特殊意义。 

用法如下：

import java.util.regex.Pattern;

public class Demo9 {

    public static void main(String[] args) {
        System.out.println(Pattern.quote("(hello)( )(world)"));
        System.out.println(Pattern.quote("hello world"));
        System.out.println(Pattern.quote("hello.world"));
    }

}

运行结果如下：

\Q(hello)( )(world)\E
\Qhello world\E
\Qhello.world\E

注意：使用 \Q 开始，\E 结束，可使\Q\E中间的标点符号失去特殊意义，将中间的字符作为普通字符。

split 方法

此方法将围绕此模式的匹配拆分给定输入序列。注意：得到的数组中不包括尾部空字符串。

例如：输入 "boo:and:foo" 将产生以下结果及表达式： 

• 表达式 “:”，产生结果 { "boo", "and", "foo" }

• 表达式 “o”，产生结果 { "b", "", ":and:f" }

用法如下：

import java.util.Arrays;
import java.util.regex.Pattern;

public class Demo10 {

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile(":");
        String[] strs = pattern.split("boo:and:foo");
        System.out.println(Arrays.toString(strs));
    }

}

运行结果如下：

[boo, and, foo]

另一个 split 方法多提供了一个 limit 参数。limit 参数控制应用模式的次数，从而影响结果数组的长度。

如果 limit 大于零，那么模式至多应用 limit - 1 次，数组的长度不大于 limit，并且数组的最后条目将包含除最后的匹配定界符之外的所有输入。

如果 limit 非正，那么将应用模式的次数不受限制，并且数组可以为任意长度。

如果 limit 为零，那么应用模式的次数不受限制，数组可以为任意长度，并且将丢弃尾部空字符串。

例如：输入 "boo:and:foo" 将产生以下结果及参数：

实例代码：

import java.util.Arrays;
import java.util.regex.Pattern;

public class Demo11 {

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile(":");
        System.out.println(Arrays.toString(pattern.split("boo:and:foo", 2)));
        System.out.println(Arrays.toString(pattern.split("boo:and:foo", 5)));
        System.out.println(Arrays.toString(pattern.split("boo:and:foo", -2)));

        pattern = Pattern.compile("o");
        System.out.println(Arrays.toString(pattern.split("boo:and:foo", 5)));
        System.out.println(Arrays.toString(pattern.split("boo:and:foo", -2)));
        System.out.println(Arrays.toString(pattern.split("boo:and:foo", 0)));
    }

}

运行结果如下：

[boo, and:foo]
[boo, and, foo]
[boo, and, foo]
[b, , :and:f, , ]
[b, , :and:f, , ]
[b, , :and:f]