java中的正则表达式And Pattern And Macher

在哪里？？

java.util.regex包下有两个用于正则表达式的类, 一个是Matcher类, 另一个Pattern

简单例子

public class RegexLeaning {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("[a-z]{3}");
        Matcher m = p.matcher("bac");
        System.out.println(m.matches());
    }
    //结果：true
}

Pattern可以理解为一个模式, 字符串需要与某种模式进行匹配，上面设置的就是匹配a-z中的三个字母

Matcher可以理解为模式匹配某个字符串后产生的结果

Pattern类中的compile方法, 也就是说对我们传入的正则表达式编译后得到一个模式对象. 而这个经过编译后模式对象, 
会使得正则表达式使用效率会大大提高, 并且作为一个常量, 它可以安全地供多个线程并发使用

第一类正则表达式：

/**
     * .    Any character (may or may not match line terminators), 任意字符
     * X?    X, once or not at all       零个或一个
     * X*    X, zero or more times       零个或多个
     * X+    X, one or more times        一个或多个
     * X{n}    X, exactly n times          x出现n次
     * X{n,}    X, at least n times     x出现至少n次
     * X{n,m}    X, at least n but not more than m times 出现n~m次

第二类正则表达式：

  /**
         * \d    A digit: [0-9]          数字
         * \D    A non-digit: [^0-9]     非数字
         * \s    A whitespace character: [ \t\n\x0B\f\r] 空格
         * \S    A non-whitespace character: [^\s]       非空格
         * \w    A word character: [a-zA-Z_0-9]          数字字母和下划线
         * \W    A non-word character: [^\w]             非数字字母和下划线
         */

[]用于描述一个字符的范围

Pattern类：

/**
         * 将给定的正则表达式编译并赋予给Pattern类
         *
         *    public static Pattern compile(String regex, int flags)
         *     public static Pattern compile(String regex)
         */
        Pattern p = Pattern.compile("a+",Pattern.CASE_INSENSITIVE);
        System.out.println(p.flags());//2

        /**
         * String pattern() 返回该pattern对象所编译的正则表达式
         */
        Pattern p1 = Pattern.compile("\\d+");
        System.out.println(p1.pattern());//\d+

String[] split()

  /**
         * String[] split() 按regex分隔字符串，返回字符串数组
         *
         *  public String[] split(CharSequence input, int limit)
         *  intput:需要财富的字符串序列
         *  limit是控制应用模式的次数，影响数组的长度
         *      n>0     :模式至少应用n-1次，数组长度不大于n。
         *      n != 正数：模式应用无限制，并且数组可任意长度
         *      n =0    ：模式应用无限制，并且数组可任意长度，丢弃尾部空字符串
         *
         *
         *   public String[] split(CharSequence input)
         */

 Pattern p2 = Pattern.compile("\\d+");
        String[] str = p2.split("全12电话89和收集");
        String[] str2 = p2.split("全12电话89和收集",2);
        System.out.println(Arrays.toString(str));//[全, 电话, 和收集]
        System.out.println(Arrays.toString(str2));//[全, 电话89和收集]

备注：因为String 实现了ChraSequence接口，所以直接可以用字符串

Pattern.matches

 /**
         * 快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.
         *
         *  public static boolean matches(String regex, CharSequence input) {
         *         Pattern p = Pattern.compile(regex);
         *         Matcher m = p.matcher(input);
         *         return m.matches();
         *     }
         */

    Boolean re1 = Pattern.matches("\\d+","232");//true
        Boolean re2 = Pattern.matches("\\d+","23aa2");//false

Pattern类中的matcher方法

  /**
         *返回一个Macher对象
         *
         *因为Matcher的构造方法也是私有的 ，不能随意创建，
         * 只能通过下面方法创建了
         * public Matcher matcher(CharSequence input)
         */

        Pattern p3 = Pattern.compile("\\d+");
        Matcher matcher = p3.matcher("2321");
        System.out.println("p3"+matcher.pattern());//返回该Matcher对象是由哪个Pattern对象的创建的

Machter类

获得实例

  Pattern pattern1 = Pattern.compile("\\d+");
        /**
         * Matcher的构造方法也是私有的，只能通过pattern类中的matcher方法创建
         */
        Matcher matcher1 = pattern1.matcher("quan1zhi2qiang3hao4");

pattern()

/**
         * Matcher中的方法pattern()获取建立matcher实例时的pattern
         * 即构造器传入的Pattern对象。
         */

System.out.println(matcher1.pattern());//\d+

matches()

 /**
         * Matcher里面的matches方法，
         * 对整个字符串进行匹配,只有整个字符串都匹配了才返回true。
         */

  String mailstr = "1234@163.com";
        Pattern pattern = Pattern.compile("[\\w\\.]+@[\\w\\-\\.]+[\\w\\-]+");
        Matcher matcher = pattern.matcher(mailstr);
        System.out.println(matcher.matches());//true

lookAt()

/**
         * Matcher.lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true。
         *lookingAt是部分匹配，总是从第一个字符进行匹配,匹配成功了不再继续匹配，匹配失败了,也不继续匹配。
         */

String str1 = "123quan";
        String str2 = "quan123";
        Pattern pattern3 = Pattern.compile("\\d+");
        Matcher matcher3 = pattern3.matcher(str1);
        Matcher matcher4 = pattern3.matcher(str2);

        System.out.println(matcher3.lookingAt());//true
        System.out.println(matcher4.lookingAt());//false
        if(matcher4.find()){
            System.out.println(matcher4.group());//123
        }

find()

  /**
         * find()是部分匹配，从当前位置开始匹配，找到一个匹配的子串，将移动下次匹配的位置。
         *
         * 该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配
         * 的第一个字符开始。如果匹配成功，则可以通过 start、end 和 group 方法获取更多信息。
         */

        String str5 = "111quan222qq333";
        Pattern pattern5 = Pattern.compile("\\d+");
        Matcher matcher5 = pattern5.matcher(str5);
        while (matcher5.find()){
            System.out.println(matcher5.group());
        }
        /*
        111
        222
        333
         */

matches lookAt find联系

        /**
         * matches lookAt  find 的联系和区别；
         *都放回boolean类型：
         * 1,Matcher.matches()   对整个字符串进行匹配,只有整个字符串都匹配了才返回true
         * 2,Matcher.lookingAt()  从输入的头开始找，只有字符串的前缀满足模式才返回true
         * 3,Matcher.find()  对字符串进行匹配,匹配到的字符串可以在任何位置.
         */

   String str6 = "111quan222qq333";
        Pattern pattern6 = Pattern.compile("\\d+");
        Matcher matcher6 = pattern6.matcher(str6);
        matcher6.matches();//匹配在q这里失败了，下次匹配位置从位置4开始

        //下次匹配
        matcher6.find();
        System.out.println(matcher6.start());//查看这次匹配成功的开始位置
        //7

        matcher6.reset();//回到初始位置
        matcher6.lookingAt();
        System.out.println(matcher6.start());//查看这次匹配成功的开始位置
        //0

替换的三个方法：

 /**
         *replaceAll 替换符合所有Regex的部分
         * replaceFirst 替换第一个符合regex的部分
         * replace 用字符串替换字符串，没有匹配规则
         */

 String str7 = "111quan222qq333";
        Pattern pattern7 = Pattern.compile("\\d+");
        Matcher matcher7 = pattern6.matcher(str7);
        System.out.println(matcher7.replaceAll("@"));//@quan@qq@
        System.out.println(matcher7.replaceFirst("*"));//*quan222qq333
        //字符串里面也有替换函数
        System.out.println(str7.replace("111","BBB"));//BBBquan222qq333
        System.out.println(str7.replaceAll("\\d+","ALL"));//ALLquanALLqqALL
        System.out.println(str7.replaceFirst("\\d+","FIRST"));//FIRSTquan222qq333

正则表达式详解：

常用书写符号：

常用限定字符：

预定义字符集：

常用regex：

public class DemoRegex {
    public static void main(String[] args) {
        String qqstr = "12898878332";
        String qqreg = "[1-9]\\d{4,13}";//QQ没有0开头的
        Pattern pattern1 = Pattern.compile(qqreg);
        Matcher matcher = pattern1.matcher(qqstr);
        boolean re = matcher.matches();
        System.out.println(re);//true

        //按照叠词切割：其中\\1表示前面括号里面的组
        String[] strings = qqstr.split("(.)\\1+");
        System.out.println(Arrays.toString(strings));//[1289, 78, 2]

    }
}

http://www.51gjie.com/java/766.html

组：

A(B(C))D 有三个组：组 0 是 ABCD，组 1 是 BC，组 2 是 C，
可以根据有多少个左括号来来确定有多少个分组，括号里的表达式都称子表达式。

"(.)\\1+"

\\1就是反向引用

https://lilinchao.com/archives/339.html