【总结】Java Pattern

应用场景

Java Pattern 与 Macher 类常用来通过正则表达式进行数据格式的校验

常用方法

Pattern

方法	简介
boolean matches(String regex, CharSequence input)	将输入字符串 input 与正则表达式 regex 进行匹配，返回匹配结果
Pattern compile(String regex)	传入正则表达式，获得一个 Pattern 对象，可以多次使用
Matcher matcher(CharSequence input)	传入待匹配的字符串，获得匹配结果对象 Matcher

Matcher

方法	简介
boolean find()	返回正则匹配的结果
String group()	返回被匹配字符串中满足正则匹配的字符串，若存在多个可配合 find() 循环取值
int start()	获得匹配字符串的起始索引
int end()	获得匹配字符串的终止索引

正则表达式元字符

在 Java 中使用时注意使用转义符，对应的测试和结果见 demo

字符	解释
无元字符	字符串与正则表达式完全一致时返回 true
\d	表示一个数字
\D	表示一个非数字
\w	表示一个大小写字母、数字、下划线
\W	表示一个非大小写字母、数字、下划线
\s	表示空格或者制表符
\S	表示一个非空格或制表符
.	表示除”\n“和”\r“之外的任意字符
|	表示逻辑关系”或“
[]	表示匹配其中的任意一个字符
[^]	表示不与其中的任何一个字符匹配
[X-X]	表示匹配 X-X 之间的任意字符
[^X-X]	表示不与范围内的任意一个字符匹配
\NUM	NUM 为数字，表示匹配第 NUM 个括号的结果
?	表示前面的子表达式出现一次或零次
+	表示前面的子表达式出现一次或多次
{n}	匹配前面确定的子表达式 n 次
{n,N}	匹配前面确定的子表达式 n 到 N 次
*	匹配前面的子表达式任意次

PatternDemo

package JavaPattern;

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

public class PatternDemo {

    public static void main(String[] args) {
        // ==================== Pattern 类的常用方法 ====================
        // (1) boolean matches(String regex, CharSequence input)：返回匹配结果
        // (2) Pattern compile(String regex)：获得一个 Pattern 对象，可以多次使用
        // (3) Matcher matcher(CharSequence input)：获得一个 Matcher 对象，存储着正则匹配的结果

        // ==================== Matcher 类的常用方法 ====================
        // (1) boolean find()：返回正则匹配的结果
        // (2) String group()：返回被匹配字符串中满足正则匹配的字符串，若存在多个可配合 find() 循环取值
        // (3) int start()：获得匹配字符串的起始索引
        // (4) int end()：获得匹配字符串的终止索引

        String strRegex = "ab*c";
        boolean result = Pattern.matches(strRegex,"ac");
        System.out.println(result); // true

        String str = "电话1：13812341234；电话2：18812344321；电话3：15843214321";
        String phoneRegex = "((13\\d)|(15\\d))\\d{8}";
        Matcher matcher1 = Pattern.compile(phoneRegex).matcher(str);
        while (matcher1.find()) {
            System.out.println(matcher1.group() + "--开始index：" + matcher1.start()+ "--结束index：" + matcher1.end());
        }
        // 13812341234--开始index：4--结束index：15
        // 15843214321--开始index：36--结束index：47

        // ==================== 正则表达式 ====================
        // (1) 正则表达式不包含元字符：字符串与正则表达式完全一致时返回 true
        String regex = "abc";
        System.out.println(check(regex, "abc123")); // false
        System.out.println(check(regex, "abcabc")); // false
        System.out.println(check(regex, "abc")); // true
        // (2) \d：表示一个数字
        regex = "abc(\\d)def";
        System.out.println(check(regex, "abc123def")); // false
        System.out.println(check(regex, "abc3def")); // true
        // (3) \D：表示一个非数字
        regex = "abc(\\D)def";
        System.out.println(check(regex, "abc3def")); // false
        System.out.println(check(regex, "abcXdef")); // true
        // (4) \w：表示一个大小写字母、数字、下划线
        regex = "ab(\\w)de";
        System.out.println(check(regex, "abCde")); // true
        System.out.println(check(regex, "abcde")); // true
        System.out.println(check(regex, "ab3de")); // true
        System.out.println(check(regex, "ab_de")); // true
        // (5) \W：表示一个非大小写字母、数字、下划线
        regex = "ab(\\W)de";
        System.out.println(check(regex, "ab_de")); // false
        System.out.println(check(regex, "ab@de")); // true
        // (6) \s：表示空格或者制表符
        regex = "ab(\\s)de";
        System.out.println(check(regex, "abcde")); // false
        System.out.println(check(regex, "ab de")); // true
        // (7) \S：表示一个非空格或制表符
        regex = "ab(\\S)de";
        System.out.println(check(regex, "abcde")); // true
        System.out.println(check(regex, "ab de")); // false
        // (8) .：表示除”\n“和”\r“之外的任意字符
        regex = "...";
        System.out.println(check(regex, "123")); // true
        System.out.println(check(regex, "abc")); // true
        System.out.println(check(regex, "_*@")); // true
        // (9) |：表示逻辑关系”或“
        regex = "ab(\\d|\\s)de";
        System.out.println(check(regex, "abcde")); // false
        System.out.println(check(regex, "ab3de")); // true
        System.out.println(check(regex, "ab de")); // true
        // (10) []：表示匹配其中的任意一个字符
        regex = "ab[3c]de";
        System.out.println(check(regex, "abXde")); // false
        System.out.println(check(regex, "ab3de")); // true
        System.out.println(check(regex, "abcde")); // true
        // (11) [^]：表示不与其中的任何一个字符匹配
        regex = "ab[^3c]de";
        System.out.println(check(regex, "abXde")); // true
        System.out.println(check(regex, "ab3de")); // false
        System.out.println(check(regex, "abcde")); // false
        // (12) [X-X]：表示匹配 X-X 之间的任意字符
        regex = "ab[a-z]de";
        System.out.println(check(regex, "abhde")); // true
        System.out.println(check(regex, "abHde")); // false
        // (13) [^X-X]：表示不与范围内的任意一个字符匹配
        regex = "ab[^0-9]de";
        System.out.println(check(regex, "ab9de")); // false
        System.out.println(check(regex, "ab@de")); // true
        // (14) \NUM：NUM 为数字，表示匹配第 NUM 个括号的结果
        regex = "(a)1b2c3d4e(5):\\1\\2";
        System.out.println(check(regex, "a1b2c3d4e5:b4")); // false
        System.out.println(check(regex, "a1b2c3d4e5:a5")); // true
        // (15) ?：表示前面的子表达式出现一次或零次
        regex = "(\\d)?abc";
        System.out.println(check(regex, "123abc")); // false
        System.out.println(check(regex, "abc")); // true
        System.out.println(check(regex, "0abc")); // true
        // (16) +：表示前面的子表达式出现一次或多次
        regex = "(\\d)+abc";
        System.out.println(check(regex, "123abc")); // true
        System.out.println(check(regex, "abc")); // false
        System.out.println(check(regex, "0abc")); // true
        // (17) {n}：匹配前面确定的子表达式 n 次
        regex = "(\\d){3}abc";
        System.out.println(check(regex, "123abc")); // true
        System.out.println(check(regex, "123123123abc")); // false
        // (18) {n,N}：匹配前面确定的子表达式 n 到 N 次
        regex = "(\\d){1,3}abc";
        System.out.println(check(regex, "123abc")); // true
        System.out.println(check(regex, "123123abc")); // false
        // (19) *：匹配前面的子表达式任意次
        regex = "(\\d)*abc";
        System.out.println(check(regex, "123abc")); // true
        System.out.println(check(regex, "123123123abc")); // true
        System.out.println(check(regex, "abc")); // true

    }

    /**
     * 校验方法
     * @param regex 正则表达式
     * @param input 被匹配字符串
     * @return 匹配结果
     */
    private static boolean check(String regex, String input) {
        return Pattern.matches(regex, input);
    }

}