java day14 正则表达式(1-9课）

为什么使用正则表达式
matches（）

package com.heima.regex;

public class Demo1_Regex {

    /**
     * * A:正则表达式
            * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
            * 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
        * B:案例演示
            * 需求：校验qq号码.
                * 1:要求必须是5-15位数字
                * 2:0不能开头
                * 3:必须都是数字

            * a:非正则表达式实现
            * b:正则表达式实现
     */
    public static void main(String[] args) {
        System.out.println(checkQQ("012345"));
        System.out.println(checkQQ("a1b345"));
        System.out.println(checkQQ("123456"));
        System.out.println(checkQQ("1234567890987654321"));

        String regex = "[1-9]\\d{4,14}";
        System.out.println("2553868".matches(regex));
        System.out.println("012345".matches(regex));
        System.out.println("2553868abc".matches(regex));
    }

    /*
     * 需求：校验qq号码.
     * 1:要求必须是5-15位数字
     * 2:0不能开头
     * 3:必须都是数字
     * 校验qq
     * 1,明确返回值类型boolean
     * 2,明确参数列表String qq
     */
    public static boolean checkQQ(String qq) {
        boolean flag = true;                    //如果校验qq不符合要求就把flag置为false,如果符合要求直接返回

        if(qq.length() >= 5 && qq.length() <= 15) {
            if(!qq.startsWith("0")) {
                char[] arr = qq.toCharArray();  //将字符串转换成字符数组
                for (int i = 0; i < arr.length; i++) {
                    char ch = arr[i];           //记录每一个字符
                    if(!(ch >= '0' && ch <= '9')) {
                        flag = false;           //不是数字
                        break;
                    }
                }
            }else {
                flag = false;                   //以0开头,不符合qq标准
            }
        }else {
            flag = false;                       //长度不符合
        }
        return flag;
    }
}

字符类
[] 代表单个字符

        [abc] a、b 或 c（简单类） 
        [^abc] 任何字符，除了 a、b 或 c（否定） 
        [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） 
        [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集） 
        [a-z&&[def]] d、e 或 f（交集） 
        [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去） 
        [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去） 

预定义字符类

        . 任何一个字符
        \d 数字：[0-9] 
        \D 非数字： [^0-9] 
        \s 空白字符：[ \t\n\x0B\f\r] 
        \S 非空白字符：[^\s] 
        \w 单词字符：[a-zA-Z_0-9] 
        \W 非单词字符：[^\w] 

        String regex = "\\d";                   //\代表转义字符,如果想表示\d的话,需要\\d = [0-9]
        System.out.println("0".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("9".matches(regex));

数量词

        Greedy 数量词 
        X? X，一次或一次也没有 
        X* X，零次或多次 （包括一次）
        X+ X，一次或多次 
        X{n} X，恰好 n 次 
        X{n,} X，至少 n 次 
        X{n,m} X，至少 n 次，但是不超过 m 次 

String regex = "[abc]?"; // 对，a或b或c出现一次或一次也没有，但不能出现其他的。
String regex2 = "[abc]*"; 

String分割功能
Split() 通过正则表达式切割字符串

"\\." 在实际编译中 就代表 .

package com.heima.regex;

public class Demo5_Split {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "金三胖.郭美美.李dayone";
        String[] arr = s.split("\\.");              //通过正则表达式切割字符串
        \\.代表任意字符，都匹配了所以切碎了，什么也没得到。所以必须用转义


        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("11111111111111111");
    }

}

替换
String类的功能：public String replaceAll(String regex,String replacement)

    public static void main(String[] args) {
        String s = "wo111ai222heima";
        String regex = "\\d";           //\\d代表的是任意数字

        String s2 = s.replaceAll(regex, ""); // 吧所有数字都替换成“”
        System.out.println(s2); // woaiheima 
    }

分组

package com.heima.regex;

public class Demo7_Regex {

    /**
     * * A:正则表达式的分组功能
            * 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 
        * 
                1     ((A)(B(C))) 
                2     (A 
                3     (B(C)) 
                4     (C) 

                组零始终代表整个表达式。
        B:案例演示
            a:切割
                需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
            b:替换
                需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
                将字符串还原成:“我要学编程”。
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();

        /*
         * 需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
                将字符串还原成:“我要学编程”。
         */
        String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
        String s2 = s.replaceAll("\\.+", ""); // 把.干掉了
        String s3 = s2.replaceAll("(.)\\1+", "$1");	//$1代表第一组中的内容
        System.out.println(s3);
    }

    public static void demo2() {
        //需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
        // sd fg hj kl
        String s = "sdqqfgkkkhjppppkl";
        String regex = "(.)\\1+";                   //+代表第一组出现一次到多次
        String[] arr = s.split(regex);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static void demo1() {
        //叠词 快快乐乐,高高兴兴
        /*String regex = "(.)\\1(.)\\2";                    //\\1代表第一组又出现一次 \\2代表第二组又出现一次
        System.out.println("快快乐乐".matches(regex));
        System.out.println("快乐乐乐".matches(regex));
        System.out.println("高高兴兴".matches(regex));
        System.out.println("死啦死啦".matches(regex));*/

        //叠词 死啦死啦,高兴高兴
        String regex2 = "(..)\\1";
        System.out.println("死啦死啦".matches(regex2));
        System.out.println("高兴高兴".matches(regex2));
        System.out.println("快快乐乐".matches(regex2));
    }

}

Pattern和Matcher
Pattern.compile 将给定的正则表达式编译到模式猴子那个
p.matcher创建匹配给定输入与此模式的匹配器

package com.heima.regex;

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

public class Demo8_Pattern {

    /**
     * Pattern p = Pattern.compile("a*b");
         Matcher m = p.matcher("aaaaab");
         boolean b = m.matches();

        * A:正则表达式的获取功能
            * Pattern和Matcher的结合使用
        * B:案例演示
            * 需求：把一个字符串中的手机号码获取出来
     */
    public static void main(String[] args) {
        //demo1();
        String s = "我的手机是18511866260,我曾用过18987654321,还用过18812345678";
        String regex = "1[3578]\\d{9}";


        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s);

        /*boolean b1 = m.find();
        System.out.println(b1);
        System.out.println(m.group());

        boolean b2 = m.find();
        System.out.println(b2);
        System.out.println(m.group());*/

        while(m.find())
            System.out.println(m.group());
    }

    public static void demo1() {
        Pattern p = Pattern.compile("a*b");                 //获取到正则表达式
        Matcher m = p.matcher("aaaaab");                    //获取匹配器
        boolean b = m.matches();                            //看是否能匹配,匹配就返回true

        System.out.println(b);

        System.out.println("aaaaab".matches("a*b"));        //与上面的结果一样
    }

}