正则表达

1.正则表达式的概述和简单使用

　　是指用来描述或匹配字符串是否符合自己的语法规则，其实就是一种规则，有自己特殊用途

　　比如注册账号时，会限制用户名和密码的长度，这个限制长度就是正则表达式做的

　

    /**
         * B:案例演示
         * 需求：校验qq号码.
         * 1:要求必须是5-15位数字
         * 2:0不能开头
         * 3:必须都是数字
         */
        
         demo1();
//         正则表达式的匹配规则，用正则表达式实现
        String regex = "[1-9]\\d{4,14}";   
        
        System.out.println("0123456".matches(regex));        //false
        System.out.println("a1234567".matches(regex));        //false
        System.out.println("930275779".matches(regex));        //true
        System.out.println(Pattern.matches(regex, "1234567"));//true
    }

    
//    用已循环和if语句实现
    public static void demo1() {
        System.out.println(checkQQ("012345"));        //false
        System.out.println(checkQQ("930275779"));    //true
        System.out.println(checkQQ("1234567891032489"));//false
        System.out.println(checkQQ("2346"));        //false
    }
    public static boolean checkQQ(String s){
        boolean flag = true;
        //限制长度 5~15 之间
        if(s.length()>=5 && s.length()<=15){
            //不能以o开头
            if(!(s.startsWith("0"))){
                // 把字符串转为字符数组
                char[] chars = s.toCharArray();
                //循环录入要判断的字符数组
                for(int i=0; i<chars.length; i++){
                    char ch = chars[i];
                    //输入的数字字符必须是0~9
                    if(!(ch>='0' && ch<='9')){
                        flag = false;
                        break;
                    }
                }
            }else {
                flag = false;   //数字以0开头
            }
        }else {
            flag = false;       // 长度不合法
        }
        return  flag;
    }

2.字符类演示

　　/**

　 　 *  [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]（减去）

 　　*/

    public static void main(String[] args) { 
//         demo1();
        // demo2();
         demo3();
        // demo4();
        // demo5();
        // demo6();
    }

    public static void demo1() {
        String regex = "[abc]"; // []表示单个字符            只有abc这几个单个字符可以匹配
        System.out.println("a".matches(regex)); // true
        System.out.println("b".matches(regex)); // true
        System.out.println("++++++++++");
        System.out.println("m".matches(regex)); // false
        System.out.println("n".matches(regex)); // false
        
    }

    public static void demo2() {
        String regex = "[^abc]";                //除了abc的单个字符以外，任何单个字符都能满足匹配
        System.out.println("a".matches(regex));    // false
        System.out.println("m".matches(regex)); // true
        System.out.println("sd".matches(regex));//false            是两个字符
    }

    private static void demo3() {
        //    取交集，也就是两个范围内，相同的单个字符     "[a-z&&[def]]"也是一样
        String regex = "[ac&&[dc]]";        
        System.out.println("a".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("%".matches(regex)); // false
    }

    private static void demo4() {
        String regex = "[a-d[m-p]]";        //取并集，就是两个范围内的所有单个字符
        System.out.println("a".matches(regex));
        System.out.println("m".matches(regex));
        System.out.println("n".matches(regex));
    }

    private static void demo6() {
        String regex = "[a-z&&[^bc]]";    //在a-z的单个字符内，除去  bc 这两个单个字符以外，都匹配
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("1".matches(regex));
    }

3.预定义字符类

　　/**
　　 *       任何字符
　　 *        \d 数字：[0-9] ---代表单个的数字字符。 \ 是转义字符
　　 *        \D 非数字： [^0-9] ----取反
　　 *        \s 空白字符：[ \t\n\x0B\f\r] 代表垂直制表符。f代表翻页dos系统里的，r回车，
　　 *        \S 非空白字符：[^\s]
　　 *        \w 单词字符：[a-zA-Z_0-9]
　　 *        \W 非单词字符：[^\w]

　　* 　　.  代表任意字符，一个点代表一个字符
　　 */

public static void main(String[] args) {
        demo1();
        demo2();
        demo3();
        demo4();
        demo5();
        demo6();
    }

    private static void demo6() {
        // \\W   取反  非单词字符
        String regex = "\\w";    //单词字符
        System.out.println("a".matches(regex)); // true
        System.out.println("z".matches(regex)); // true
        System.out.println("_".matches(regex)); // true
        System.out.println("9".matches(regex)); // false
    }

    private static void demo5() {
        String regex = "\\S";        // 取反 ，非空白字符
        System.out.println(" ".matches(regex)); // 空格 false
        System.out.println("   ".matches(regex)); // tab键 false
        System.out.println("a".matches(regex)); // true
    }

    private static void demo4() {
        String regex = "\\s"; // 匹配空白
        System.out.println(" ".matches(regex));                        //true
        System.out.println("    ".matches(regex)); // 一个tab键        true
        System.out.println("    ".matches(regex)); // 四个空格        false
    }

    private static void demo3() {
        String regex = "\\D";    // [^0-9]取反，除了数字字符以外都为true
        System.out.println("0".matches(regex)); // false
        System.out.println("9".matches(regex)); // false
        System.out.println("a".matches(regex)); // true
    }

    private static void demo2() {
        String regex = "\\d"; // \代表转义字符,如果想表示\d的话,需要\\d        代表[0-9]单个的数字字符，    
        System.out.println("0".matches(regex)); // true
        System.out.println("a".matches(regex)); // false
        System.out.println("9".matches(regex)); // true
    }

    private static void demo1() {
        String regex = "..";// 点代表任意字符， 一个点代表一个字符，两个点代表两个字符。
        System.out.println("a".matches(regex)); // f
        System.out.println("ab".matches(regex)); // t
    }

4.数量词

　　

　　* A:Greedy 数量词 

　　* X? X，一次或一次也没有

　　* X* X，零次或多次

　　* X+ X，一次或多次

　　* X{n} X，恰好 n 次 

　　* X{n,} X，至少 n 次 

　　* X{n,m} X，至少 n 次，但是不超过 m 次

    public static void main(String[] args) {
         demo1();
         demo2();
         demo3();
         demo4();
         demo5();
         demo6();
    }

    private static void demo6() {
        String regex = "[abc]{5,15}";//范围内的单个字符出现了至少5次，但不超过15次
        System.out.println("abcba".matches(regex));                //true
        System.out.println("abcbaabcabbabab".matches(regex));    //true
        System.out.println("abcb".matches(regex));                //false
        System.out.println("abcbaabaabcbaaba".matches(regex));    //false
    }

    public static void demo5() {
        String regex = "[abc]{5,}";    //范围内的单个字符至少出现了5次，
        System.out.println("abcba".matches(regex));            //true
        System.out.println("abcbaabcabbabab".matches(regex));//true
        System.out.println("abcb".matches(regex));            //false
        System.out.println("abcbaaba".matches(regex));        //true
    }

    public static void demo4() {
        String regex = "[abc]{5}";    //范围内的单个字符 恰好出现了5次，
        System.out.println("abcba".matches(regex));                //true
        System.out.println("abcbaabcabbabab".matches(regex));    //false
        System.out.println("abcb".matches(regex));                //false
        System.out.println("abcbaaba".matches(regex));            //false
    }

    public static void demo3() {
        String regex = "[abc]+";    //范围内的单个符出现了一次或多次
        System.out.println("".matches(regex));                //false        一次没出现false
        System.out.println("a".matches(regex));                //true
        System.out.println("aaaaabbbbccccc".matches(regex));//true
    }

    public static void demo2() {
        String regex = "[abc]*";    //     范围内的单个字符只出现零次或多次    出现一次也正确
        System.out.println("".matches(regex));                //true
        System.out.println("abc".matches(regex));            //true
        System.out.println("a".matches(regex));                //true
        System.out.println("v".matches(regex));                //false
    }

    public static void demo1() {
        String regex = "[abc]?";    // 范围内的单个字符只出现了一次或一次也没有    空的也是true
        System.out.println("a".matches(regex));                //true
        System.out.println("b".matches(regex));                //trrue
        System.out.println("d".matches(regex));                //false
        System.out.println("".matches(regex));                //true
    }

5.正则表达式的分割功能　　

/**
 * *A:正则表达式的分割功能
 *        * String类的功能：public String[] split(String regex)
 *      Split(“.”).表示任意字符。要转义 \\ .
 *     * B:案例演示
 *        * 正则表达式的分割功能
 */

　　split（）是分割方法

public static void main(String[] args) {
        String s = "我们,是,一家人";
        String[] arr = s.split(",");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("++++++++++++");
    }

　　　　//输出结果为  我们
　　　　　　　　　　 　是
　　　　　　　　　　　 一家人

6.把给定字符串中的数字排序

 　　　　

        String str = “98，99，23”’
            int[] arr = new int [str.length];   
                    for(int i = 0  ; i < arr.length; i++){
                          //把字符串转成数字
                         arr[i] = Integer.parseInt(str.[i]);
                         }    
                         //给数字数组排序
                     Arrays.sort(arr)；    

　　

/*
         * 1.先把空格切分开
         * 2.再把字符串转成字符数组，
         * 3.再把字符数组转成int类型，
         * 4.再用函数进行排序输出
         */
        String str = "23 34 73 45 43";
        //转成字符数组
        String[] arr = str.split(" ");
        //声明一个长度和str字符数组一样长度的数组
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            //用函数把字符数组转成int类型的数组
            arr1[i] = Integer.parseInt(arr[i]);
        }
        //用方法把int类型的数组进行排序
        Arrays.sort(arr1);
        //再用增强for循环输出
        for (int i : arr1) {
            System.out.println(i);
        }
        //输出结果为 23 34 43 45 73
        
        /**
         * 如果不把字符数组转成int类型的数组，进行排序的话，系统是按照字典顺序取排序的，
         * 比如在字符串中加入100，
         * 他的排序会变成  100 23 34 43 45 73
         */

 

 

7.正则表达式的分组和替换功能

 

　　（.）\\1

　　（.）\\1+　　　　是指匹配多个重复字符

　　replaceAll(String regex,String replacement);　　是替换功能 把括号内前半部分替换成后半部分

                /* 
                 * 分组功能一个点代表匹配一个字符，
                 * \\1代表第一组又出现一次     \\2代表第二次又出新一次
                 */
        String regex = "(.)\\1(.)\\2";
        System.out.println("快快乐乐".matches(regex));
        
        String regex1 = "(..)\\1";
        System.out.println("恭喜恭喜".matches(regex1));

    　　//创建一个字符串
        String str = "assssddddddddddesdsssss";
        //声明一个规则
        String regex = "(.)\\1+";
        //把字符串转成字符数组,并把规则匹配进去
        String [] arr = str.split(regex);
        for (String string : arr) {
            System.out.println(string);
        }

/*
         * 1.把点去掉，用替换功能replaceAll
         * 2.再用分组功能吧重复字符去掉，只保留一次
         */
        String str = "我我我我...要..要....要..学学....学编编..编程...程程";
        //替换掉点：输出结果为：我我我我要要要学学学编编编程程程
        String str1 = str.replaceAll("\\.","");
        //使用正则表达式只保留一次重复字符
        String str2 = str1.replaceAll("(.)\\1+","$1");//$1代表第一组中的内容
        //输出结果为 ：我要学编程
        System.out.println(str2);

 8.正则获取功能

 　　pattern类   match类　　

    //使用Pattern和Mathcher类实现正则表达式的匹配    
    Pattern p = Pattern.compile("a*b");
    Matcher m = p.matcher("aaaaab");
    boolean b = m.matches();
    System.out.println(b);
    
    //我们直接使用的是字符串自己的matches方法进行正则表达式的匹配
    System.out.println("aaab".matches("a*b"));
        
        
    }