Java - 正则简单学习

1. 基本使用演示

//正则表达式练习
        //校验QQ号
        //要求:必须是5-15位的数字,0不能开头，必须都是数字

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的QQ号:");
        String qq = sc.nextLine();

        //调用这个非正则的方法
//        boolean isQQ = checkQQ(qq);
//        System.out.println(isQQ);

       boolean isQQ = zhengceQQ(qq);
        System.out.println(isQQ);

    }
    //2.正则实现--正则满足一定条件限制规则的字符串
    //[1-9]:可以是1到9的数字，\\d:任意的数字字符,{4,14}:代表4到14个字符
    //为什么是4-14个，因为[1-9]那里限制了开头是[1-9]的数字中一个，就有一个了

    public static boolean zhengceQQ(String qq){
        boolean flag = true;
        String regex = "[1-9]\\d{4,14}";
        if (!qq.matches(regex)){
            //matches:String的方法:判断这个字符串是否匹配这个正则
             flag = false;
            System.out.println("无法匹配");
        }
        return  flag;
    }

    //1.非正则实现
    public static boolean checkQQ(String qq){
        boolean flag = true;
        if (qq.length() >= 5 && qq.length() <= 15){
            if (!qq.startsWith("0")){
                //将字符串转换为字符数组
                char[] ch = qq.toCharArray();
             for (int i = 0; i < ch.length; i++) {
                   char c = ch[i];
                   if (!(c >= '0' && c <= '9')){
                       flag = false;
                       System.out.println("不全是数字");
                       break;//只要有一个不是数字我就立马跳出循环
                   }
             }
            }else{
                flag = false;
                System.out.println("以0开头了");
            }
        }else{
            flag = false;
            System.out.println("长度不符合");
        }

        return flag;
    }

2. 字符类

 /*
    A:字符类
      * [abc] a、b 或 c（简单类）
    * [^abc] 任何字符，除了 a、b 或 c（否定）
    * [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
    * [0-9] 0到9的字符都包括
  */

    //1. []:中括号是代表单个字符 [abc]:代表这个字符是abc三个字符中的一个
        String regx = "[abc]";
        System.out.println("c".matches(regx));
        System.out.println("1-----------------------");

    //2. [^abc]:还是单个字符，但是是否定的，除了abc，可以是其它任意的字符.
        String regx1 = "[^abc]";
        System.out.println("0".matches(regx1));
        System.out.println("t".matches(regx1));
        System.out.println("b".matches(regx1));
        System.out.println("10".matches(regx1));//这个也是false,因为10是两个字符了
        System.out.println("2-----------------------");
    //3. [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
        String regx2 = "[a-zA-Z]";
        System.out.println("0".matches(regx2));
        System.out.println("H".matches(regx2));
        System.out.println("3-----------------------");
    //4.[0-9] 0到9的字符都包括
    //5. [a-e[m-p]]:a-e或者m-p的范围,和3是差不多的写法
        String regx3 = "[a-e[m-p]]";
        System.out.println("c".matches(regx3));
        System.out.println("v".matches(regx3));
        System.out.println("5-----------------------");
    //6. [a-t&&[c-t]]:取两者的交集
        String regx4 = "[a-d&&[c-t]]";//其实就只有cd满足，和直接写cd的效果是一样的
        System.out.println("c".matches(regx4));
        System.out.println("d".matches(regx4));
        System.out.println("t".matches(regx4));
        System.out.println("6-----------------------");
    }

3.字符类2

 /*
         . :代表任意字符
    */

        //1.. 任意字符
        //.. :两个字符
        String regx = ".";
        System.out.println("j".matches(regx));
        String regx1 = "..";
        System.out.println("ab".matches(regx1));
        System.out.println("1----------------");

        //2.\d : 数字 == [0 - 9];
        String regx2 = "\\d";//因为\反斜线是转义字符，如果想写\d，需要在前面再加一个\
        System.out.println("9".matches(regx2));
        System.out.println("o".matches(regx2));
        System.out.println("2----------------");

        //3. \D :非数字 == [^0-9];
        String regx3 = "\\D";
        System.out.println("8".matches(regx3));
        System.out.println("d".matches(regx3));
        System.out.println("3----------------");

        //4. \s :空白字符 == [ \t\n\x0b\f\r]
        String regx4 = "\\s";
        System.out.println(" ".matches(regx4));
        System.out.println("    ".matches(regx4));//一个tab键
        System.out.println("8".matches(regx4));
        System.out.println("4----------------");

        //5. \S :非空白字符
       //6. \w :单词字符 == [a-zA-Z_0-9]
       //7. \W :非单词字符

4. 数量词

//数量词
        //demo1();
        //demo2();
        //demo3();
        //demo4();
        //demo5();
        String regex = "[abc]{5,15}";//至少5次，不超过15次，包含头尾
        System.out.println("abcba".matches(regex));
        System.out.println("abcbaabcabbabab".matches(regex));
        System.out.println("abcb".matches(regex));
        System.out.println("abcbaabaabcbaaba".matches(regex));
    }

    public static void demo5() {
        String regex = "[abc]{5,}";//5次到无穷大
        System.out.println("abcba".matches(regex));
        System.out.println("abcbaabcabbabab".matches(regex));
        System.out.println("abcb".matches(regex));
        System.out.println("abcbaaba".matches(regex));
    }

    public static void demo4() {
        String regex = "[abc]{5}";//恰好出现5次，前面的限定是abc中任选一个出现5次
        System.out.println("abcba".matches(regex));
        System.out.println("abcbaabcabbabab".matches(regex));
        System.out.println("abcb".matches(regex));
        System.out.println("abcbaaba".matches(regex));
    }

    public static void demo3() {
        String regex = "[abc]+";//一次或者多次
        System.out.println("".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("aaaaabbbbccccc".matches(regex));
    }

    public static void demo2() {
        String regex = "[abc]*";//代表0次或者多次
        System.out.println("".matches(regex));//0次出现
        System.out.println("abc".matches(regex));//多次出现
        System.out.println("a".matches(regex));
    }

    public static void demo1() {
        String regex = "[abc]?"; //针对abc三个字符，可以出现一次或者一次也没有，但是也不能是其它字符
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println("".matches(regex));//一次也没有
    }

5. 分割功能

//分割功能
        //演示:
        String s = "帅哥 美女 跃马";
        //调用字符串的分割方法--返回值是数组
        String[] arr = s.split(" ");//传入的是正则表达式
        //以空格分割
        for (int i = 0; i < arr.length; i++){

            System.out.println(arr[i]);

        }
        System.out.println("1-------------------");
        //2.再举个不同的
        String s1 = "C罗.梅西.皇马";
        //上面的字符串我们分割如果直接用"."分割是不行的
        String[] arr1 = s1.split("\\.");//这里不能直接用"."切割，因为直接的一个.代表的是任意字符，这样切割把字符串切碎了
        //需要转义:\\.
        for (int i = 0; i < arr1.length; i++){

            System.out.println(arr1[i]);

        }
        System.out.println("2-------------------");
        //练习:如下字符串: 91,34,55,59,80 排序从小到大
        //1.将字符串切割为字符串数组
        //2.转换为int[]组，进行排序。
        //3.将排序后的结果遍历并拼接为字符串
        String s3 = "78 89 76 34 63 23 12";
        String[] arr3 = s3.split(" ");
        //创建一个长度和arr3相等的int[]
        int[] arr4 = new int[arr3.length];
        for (int i = 0; i < arr3.length; i++){
            //调用Integer类的方法将数字字符串转为数字
            arr4[i] = Integer.parseInt(arr3[i]);
        }
        //冒泡排序--排序还可以用Arrays类的排序方法哦!
        for (int i = 0; i<arr4.length; i++){
             for (int j = 0; j < arr4.length - 1 -i; j++){
                 if (arr4[j] > arr4[j+1]){
                     int temp = arr4[j];
                     arr4[j] = arr4[j+1];
                     arr4[j+1] = temp;
                 }
             }
        }
        //把数字转成字符数组
        for (int i = 0; i < arr4.length; i++){
            arr3[i] = String.valueOf(arr4[i] + " " );
        }
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < arr3.length; i++){

            sb = sb.append(arr3[i]);
        }
        System.out.println(sb);
    }

6. 替换功能

   //替换功能
       // public String replaceAll(String regex, String replacement):replacement:传要用什么替换
        String s = "我爱1科比44麦迪";
        //需求把字符串中的数字替换掉
        String regex = "\\d"; //\\d :代表数字
        String result = s.replaceAll(regex,"");
        System.out.println(result);

7. 分组功能

 //分组功能
        //1.练习写个叠词的正则:日日夜夜,高高兴兴
        //解释:.是代表第一个可以是任意字符,加上括号代表一组。 \\1代表第一组要重复一次
        String regex = "(.)\\1(.)\\2";//\\2:代表第二组又出现一次
        System.out.println("jjii".matches(regex));
        System.out.println("1-----------------------");
        //2. 笨蛋笨蛋
        String regex1 = "(..)\\1";
        System.out.println("死啦死啦".matches(regex1));
        System.out.println("2------------------------");

        //3.练习:切割字符串中的叠词 :yhajkhhhdkdkhhhhhsbbbdkkkkeohab;
        String s = "yhajkhhhdkdkhhhhsbbbdkkkkeohab";
        String regex3 = "(.)\\1+";//我们加了一个+号，就代表这个q这一个字符可以出现一次或者多次时切割
        String[] arr = s.split(regex3);
       for (int i = 0; i < arr.length; i++){
           System.out.println(arr[i]);
       }

       //4.练习:将这个字符串还原为：我是篮球大神
        String s5 = "我.....是是是..是是.是..篮...篮篮..球.....大大大.大大....大.....神";
        //1.先将.替换为"";
        String s6 = s5.replaceAll("(.)\\1+","");//替换有重复两个或两个以上的字符
        System.out.println(s6);
        String s7 = s6.replaceAll("\\.","");
        System.out.println(s7);

        //2.第二种做法
        String s8 = s5.replaceAll("\\.","");//先去掉.
        String s9 = s8.replaceAll("(.)\\1+","$1");//"$1":代表第一组中的内容
        System.out.println(s9);

8. Pattern类和Matcher类的使用

 //1.Pattern类和Matcher类的简单使用
        Pattern p = Pattern.compile("(.)\\1(.)\\2"); //获取到一个正则表达式
        Matcher ma = p.matcher("aabb");//通过这个方法返回一个匹配器
        //就相当于说:看这个字符串是否能拿这个正则匹配上
        boolean b = ma.matches(); //这个方法的意思是:如果你能匹配上就返回true不能就是false
        System.out.println(b);
        //我日，感觉没有什么卵用啊！
        System.out.println("1-----------------");

        //2.Pattern和Matcher的运用
        //需求:将一个字符串中的手机号获取出来
        String s = "我的手机号码市13989786666这个手机号要值100万啊，我还有个手机号是:18888889999";
        //写个手机正则
        //解释这个手机正则:第一位为1，第二位是在35789中选择吧，后面的都是数字,一共出现9次
        String regex = "1[3578]\\d{9}";
        Pattern p1 = Pattern.compile(regex);
        Matcher ma1 = p1.matcher(s);
        //boolean b2 = ma1.matches();//直接用这个方法匹配出来，肯定是false
        //我们用Matcher中的另一个方法
//        boolean b1 = ma1.find();//find方法，就是查找到有就返回
//        System.out.println(b1);
        //获取找到的东西
//        String s1 = ma1.group();//调用这个方法，必须先调用find()确认能够找到这个匹配的东西
//        System.out.println(s1);
           while (ma1.find()){
               System.out.println(ma1.group());
           }