1. Pattern 类

1.1 示例模板

public class RegexDemo {
    private static final String ENTIRE_REGEX = "(.|\\s)*";
    // 子串
    private static final String SUB_SEQUENCE_REGEX = "code\\d+";
    private static final String GROUP_REGEX = "(name\\d+).*(code\\d+)";

    private static final Pattern subSequenceCompile = Pattern.compile(SUB_SEQUENCE_REGEX);
    private static final Pattern groupCompile = Pattern.compile(GROUP_REGEX);
    private static final Pattern entireCompile = Pattern.compile(ENTIRE_REGEX);

    public static void print(Object o) {
        System.out.println(o);
    }
}

1.2 matches()

public class RegexDemo {
    /**
     * 先编译这个模式
     */
    private static final Pattern pattern = Pattern.compile("[a-z]{3}");

    @Test
    public void test() {
        Matcher matcher = pattern.matcher("xyz");
        // matches 永远匹配整个字符串
        print(matcher.matches());

        // 链式写法：Pattern.compile(regex).matcher(input).matches()
    }

    public static void print(Object o) {
        System.out.println(o);
    }
}

1.3 reset()

@Test
public void test() {
    String str = "123-3243-564-00";
    Pattern pattern = Pattern.compile("\\d{3,5}");
    Matcher m = pattern.matcher(str);

    System.out.println(m.matches());
    // m.reset(); 很重要，让 m.matches() 吃掉的字符吐出来
    m.reset();
}

1.4 Pattern 与 Matcher

Matcher 可以理解为“某次具体匹配的结果对象”：把编译好的Pattern 对象“应用”到某个String对象上，就获得了作为“本次匹配结果”的Matcher对象

public final class Pattern implements java.io.Serializable {
    public static Pattern compile(String regex) {
        return new Pattern(regex, 0);
    }

    public Matcher matcher(CharSequence input) {
        if (!compiled) {
            synchronized(this) {
                if (!compiled)
                    compile();
            }
        }
        Matcher m = new Matcher(this, input);
        return m;
    }
}

public final class Matcher implements MatchResult {\
    public boolean matches() {
        return match(from, ENDANCHOR);
    }
}

2. find()

• 每调用一次 find() 方法，如果返回 true，就表示“找到一个匹配”

public class RegexDemo {
    private static final String regex = "\\d{3,5}";
    private static final Pattern pattern = Pattern.compile(regex);

    @Test
    public void find() {
        String str = "123-4567-00";
        Matcher matcher = pattern.matcher(str);

        // 找子串，找到一个子串，然后把该子串去掉
        print(matcher.find());
        print(matcher.find());
        print(matcher.find());

        print("=====================");

        // lookingAt 每次从头开始找
        print(matcher.lookingAt());
        print(matcher.lookingAt());
        print(matcher.lookingAt());
    }
    public static void print(Object o) {
        System.out.println(o);
    }
}

2.1 start() / end()

@Test
public void startfind() {
    String str = "123-4567-00";
    Matcher m = pattern.matcher(str);

    print(m.find() + "; " + m.start() + "-" + m.end());
    print(m.find() + "; " + m.start() + "-" + m.end());
    print(m.find());
    // p(m.start() + "-" + m.end()); 找不到会报错
}

3. group()

3.1 分组

• 分组由小括号组成，一个小括号是一组
• 多层嵌套：左小括号开始，第一个左括号是第一组，第二个是第二组

示例：

regex = "\\d{3,5}[a-z]{2}"  # 不加小括号
regex = "(\\d{3,5})([a-z]{2})"

3.2 group(0)

• matcher.group() 等价 matcher.group(0)
• Matcher.group(0) 表示正则表达式中符合条件的字符串。（整个匹配）
• Matcher.group(1) 表示正则表达式中符合条件的字符串中的第一个()中的字符串

// java.util.regex.Matcher#group()
public String group() {
    return group(0);
}

@Test
public void group() {
    Pattern pattern = Pattern.compile("(\\d{3,5})([a-z]{2})");
    Matcher matcher = pattern.matcher("123aa-23232re-3434");
    while (matcher.find()) {
        print(matcher.group());
        print(matcher.group(1) + "###" + matcher.group(2));
    }
}

@Test
public void group2() {
    Pattern pattern = Pattern.compile("\\d{3,5}[a-z]{2}");
    Matcher matcher = pattern.matcher("123aa-23232re-3434");
    while (matcher.find()) {
        print("group(): " + matcher.group());
        print("group(0): " + matcher.group(0));
    }
}

3.3 替换

@Test
public void test() {
    // CASE_INSENSITIVE: Enables case-insensitive matching.
    Pattern pattern = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher("java Java JaVA learnJAVA hellojAVA 2342342");
    // while (matcher.find()) {
    //     print(matcher.group());
    // }
    System.out.println(matcher.replaceAll("JAVA"));
}

private static final String regex = "java";
private static final Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

@Test
public void replaceMent() {
    Matcher matcher = pattern.matcher("java Java JaVA learnJAVA hellojAVA 2342342");

    // 单双数
    StringBuffer buffer = new StringBuffer();
    int i = 0;
    while (matcher.find()) {
        i++;
        if (i % 2 == 0) {
            // 替换的结果放到 buffer
            matcher.appendReplacement(buffer, "java");
        } else {
            matcher.appendReplacement(buffer, "JAVA");
        }
    }
    // 把后面的添加到buffer
    matcher.appendTail(buffer);
    print(buffer);
}

@Test
    public void test() {
        String data = "wer1231xiao001,23423xiao222,333xing11,2323";
        // 是否匹配子串
        // subSequenceCompile.matcher(data).find() -- boolean
        // Pattern.matches(ENTIRE_REGEX, data);  等价 entireCompile.matcher(data).matches()
        Matcher subMatcher = subSequenceCompile.matcher(data);
        while(subMatcher.find()) {
            System.out.println(subMatcher.group()); // 等价 subMatcher.group(0);
        }

        Matcher groupMather = groupCompile.matcher(data);
        while(groupMather.find()) {
            System.out.println(groupMather.groupCount());
            // xiao001,23423xiao222,333xing11; group1:xiao001; group2:xing11
            System.out.println(groupMather.group() + "; group1:" + groupMather.group(1) + "; group2:" + groupMather.group(2));
        }
    }

4. 贪婪与非贪婪

@Test
public void quantifiers() {
    String str = "aaaa5bbbb6";
    /**
     * regex = "(.{3,10})[0-9]"
     * regex = "(.{3,10}?)[0-9]"  --> X{n,m}?
     * regex = "(.{3,10}+)[0-9]"  --> X{n,m}+
     * 试试：(.+?)[0-9]
     */
    Pattern pattern = Pattern.compile("(.{3,10}+)[0-9]");
    Matcher matcher = pattern.matcher(str);
    if (matcher.find()) {
        print(matcher.start() + "---" + matcher.end());
    } else {
        print("not match");
    }
}