java中正则表达式的一些应用和总结

java 中与正则表达式有关的类方法使用

java.util.regex.Pattern 声明一个正则表达式。

java.util.regex.Matcher 提供的各种正则匹配、结果获取方法。

java.lang.String.replaceAll 根据正则表达式匹配并替换。

1. Pattern 创建一个正则对象

Pattern pattern = Pattern.compile("\\{[yMdHhms][yMdHhms -:/\\\\]*\\}");

2. 获得匹配工具Matcher对象

String var = "张三作业{yyyy-MM-dd}";
Matcher matcher = pattern.matcher(var);

3. 使用Matcher提供的 matches \ lookingAt \ find \ start \ end \ group 对字符串进行匹配、获取结果等操作

    1）matches：根据正则表达式全部匹配字符串
    例子， 匹配输入字符串中是否有{日期格式}，使用第一个正则将不能匹配成功，使用第二个将匹配成功，如果想获得{日期格式}的具体子字符串以及匹配上的子串的起始结束位置的话可以使用group、start、end来获得，前提是正则表达式要有分组信息，使用第3个正则将输入匹配到的group字符串已经起始结束字符位置。

        String var = "张三的作业{yyyy-MM-dd} 没有完成。";
        String patternStr = "\\{[yMdHhms][yMdHhms -:/\\\\]*\\}";
        String patternStr2 = ".*\\{[yMdHhms][yMdHhms -:/\\\\]*\\}.*";
        String patternStr3 = ".*(\\{[yMdHhms][yMdHhms -:/\\\\]*\\}).*";
        Pattern pattern = Pattern.compile(patternStr3);
        Matcher matcher = pattern.matcher(var);
        boolean result = matcher.matches();
        System.out.println(result);
        int n = matcher.groupCount();
        if(n > 0){
            for(int i=1; i<=n; i++){
                System.out.println("matche group :" + matcher.group(i));
                System.out.println("begin charAt :" + matcher.start(i) + "end charAt :" + matcher.end(i));
            }
        }

    2）find：根据正则表达式，部分匹配字符串。与matches不同在于不是匹配整个输入字符串，只要部分字符串匹配即可返回true,再次调用可以在上一次匹配到的子字符串后继续进行匹配
    例子，获得字符串中所有匹配到{日期格式}的字串内容  

    String var = "张三的作业{yyyy-MM-dd} 没有完成。{yyyy/MM/dd HH:mm:ss}前补交。 ";
    String patternStr = "\\{[yMdHhms][yMdHhms -:/\\\\]*\\}";
    Pattern pattern = Pattern.compile(patternStr);
    Matcher matcher = pattern.matcher(var);
    while(matcher.find()){
        System.out.println(matcher.group());    
    }

    3）lookingAt：根据正则表达式，只会从第1个字符开始进行匹配。与find不同在于，lookingAt只匹配到第一个子串就返回，多次执行也只是匹配第一个。
    例子，查看并获取字符串中开头的{日期格式}内容

    String var = "张三的作业{yyyy-MM-dd} 没有完成。{yyyy/MM/dd HH:mm:ss}前补交。 ";
    String var2 = "{yyyy-MM-dd} 没有完成。{yyyy/MM/dd HH:mm:ss}前补交。 ";
    String patternStr = "\\{[yMdHhms][yMdHhms -:/\\\\]*\\}";
    Pattern pattern = Pattern.compile(patternStr);
    Matcher matcher = pattern.matcher(var2);
    if(matcher.lookingAt()){
        System.out.println("matche group :" + matcher.group());
        System.out.println("begin charAt :" + matcher.start() + "end charAt :" + matcher.end());
    }

    4） group ：获得上一次匹配成功的子串，Returns the input subsequence matched by the previous match. 需要注意的是在matches后使用group，如果一个()组可以匹配到多个，那么matcher.group(组号)获得的是最后一次匹配到的子串，start\end 同理，因为matches会一次性匹配完全部字符串

    例子，分组匹配字符串中的连续数字和字母，再获得第1、2组的结果，分别是{1231}和aesd

        String var = "{123}asdf{1231}aesd";
        Pattern pattern = Pattern.compile(".*(\\{\\d*\\})([a-zA-Z]+).*");     
        Matcher matcher = pattern.matcher(var);
        matcher.matches();
        for(int i=1; i<=matcher.groupCount(); i++){
            System.out.println(matcher.group(i));
            System.out.println("start :" + matcher.start(i) + " end :" + matcher.end(i));
        }
        //System.out.println(matcher.group(3)); 将会报错，没有第3组

4. repalceAll 替换匹配到的结果，匹配方式类似find
   例子，将字符串中的{日期}格式的字串，替换成"{日期}"，再看一下replaceAll的源码

    String var = "张三的作业{yyyy-MM-dd} 没有完成。{yyyy/MM/dd HH:mm:ss}前补交。 ";
    var = var.replaceAll("\\{[yMdHhms][yMdHhms -:/\\\\]*\\}", "{日期}");
    System.out.println(var);

    public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

    public String replaceAll(String replacement) {
        reset();
        boolean result = find();
        if (result) {
            StringBuffer sb = new StringBuffer();
                do {
                    appendReplacement(sb, replacement);
                    result = find();
                } while (result);
                appendTail(sb);
                return sb.toString();
        }
        return text.toString();
    }