Java之正则表达式

package test_demo.zhengzebiaodashi;

import org.junit.Test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ZhengZeClass {

/*
 *  java.util.regex 包主要包括以下三个类：
 *  Pattern 类：
 *      pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。
 *      要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
 *  Matcher 类：
 *      Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。
 *      你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
 *  PatternSyntaxException：
 *      PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
 *  详细查看：http://www.runoob.com/java/java-regular-expressions.html
 */

    /**
     * 判断文本是否包含某字符串
     * -使用了正则表达式 .*runoob.* 用于查找字符串中是否包了 runoob 子串
     */
    @Test
    public void testMatches() {
        String content = "I am noob " +
                "from runoob.com.";
        System.out.println("content:" + content);

        String pattern = ".*runoob.*";
        System.out.println("pattern:" + pattern);

        boolean isMatch = Pattern.matches(pattern, content);
        System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
    }

    /**
     * 分割字符串
     * -Matcher.find()方法是部分匹配；Matcher.matches()方法是全部匹配
     * -group(0)表示整个表达式
     */
    @Test
    public void testMatchesGroup() {
        // 按指定模式在字符串查找
        String content = "This order was placed for QT3000! OK?";
        String pattern = "(\D*)(\d+)(.*)";
        // 创建 Pattern 对象
        Pattern r = Pattern.compile(pattern);
        // 现在创建 matcher 对象
        Matcher m = r.matcher(content);
        if (m.find()) {
            System.out.println("group(0) value: " + m.group(0));
            System.out.println("group(1) value: " + m.group(1));
            System.out.println("group(2) value: " + m.group(2));
            System.out.println("group(3) value: " + m.group(3));
            System.out.println("分组总数：: " + m.groupCount());
        } else {
            System.out.println("NO MATCH");
        }
    }

    @Test
    public void testMatchesHbasePut() {
        String content = "put 't_test','test-ugid','f1:phone_no','15261851357'";
        String putPattern = "^put\s*'(.*?)'\s*,\s*'(.*?)'\s*,\s*'f1:(.*?)'\s*,\s*'(.*?)'$";
        Pattern p = Pattern.compile(putPattern);
        Matcher m = p.matcher(content);
//        matches()方法是全部匹配
        if (m.matches()) {
            System.out.println("group(0) value: " + m.group(0));
            System.out.println("分组总数：: " + m.groupCount());
            for (int i = 1; i <= m.groupCount(); i++) {
                System.out.println("group(" + i + ") value: " + m.group(i));
            }
        }
    }

    /**
     * 统计匹配次数
     * -Start方法返回之前的匹配操作期间，由给定组所捕获的子序列的初始索引；
     * -end方法为最后一个匹配字符的索引加1。
     */
    @Test
    public void testMatchNumber() {
//        匹配一个字边界，即字与空格间的位置。
        String REGEX = "\bcat\b";
        String INPUT = "cat cat cat cattie cat";

        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(INPUT); // 获取 matcher 对象
        int count = 0;

        while (m.find()) {
            count++;
            System.out.println("Match number: " + count);
//            Start方法返回之前的匹配操作期间，由给定组所捕获的子序列的初始索引。
            System.out.println("start(): " + m.start());
//            end方法为最后一个匹配字符的索引加1。
            System.out.println("end(): " + m.end());
        }
    }

    /**
     * 文本替换
     * -replaceFirst方法用来替换首次匹配正则表达式的文本；
     * -replaceAll方法用来替换所有匹配正则表达式的文本。
     */
    @Test
    public void testReplaceAll() {
        String REGEX = "dog";
        String INPUT = "The dog says meow. All dogs say meow.";
        String REPLACE = "cat";

        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(INPUT);
//        INPUT = m.replaceFirst(REPLACE);
        String output = m.replaceAll(REPLACE);

        System.out.println("替换前：" + INPUT);
        System.out.println("替换后：" + output);
    }

}