java 正则表达式

正则表达式API：正则表达式

1.字符类

        字符类(只能匹配一位)
        1.匹配简单的 固定的字符
          [abC]          ->    只能匹配到 a、b、C
          [a-z]          ->    能匹配到a~z
        2.匹配简单的 不是固定的某个字符
          [^aBc]         ->    能匹配任何字符, 除了a、B、c
          [^a-z]         ->    能匹配任何字符, 除了a~z
        3.并集 (逻辑加,或)
         3.1 [a-zQ-Z]    ->    a~z或者Q~Z = [a-z[Q-Z]]
         3.2 [a[m-p]]    ->    a或者m~p   = [am-p]
        4.交集 (逻辑乘,与)
         4.1[a-e&&[c-f]] ->    a~e并且c~f  = [c-e]
         4.2[a-z&&[^bc]] ->    a~z并且不是b或者c  =  [a[d-z]] =[ad-z]
         4.3[a-z&&[^b]]  ->    a~z 减去了 b = [a[c-z]]
         4.4[a-z&&[^m-p]]->    a~z 减去了 m-p  = [a-lq-z] =[a-l[q-z]]

2.预处理字符类

        预定义字符类(也只能匹配一位)
        .                ->    任何字符
        \d               ->    数字[0-9]
        \D               ->    非数字[^0-9]
        \s               ->    空白字符[ \t\n\x0B\f\r]
        \S               ->    非空白字符[^\s]
        \w               ->    单词字符[a-zA-Z_0-9]
        \W               ->    非单词字符[^\w]

3.边界匹配器

        边界匹配器
        ^                ->     行的开头
        $                ->     行的结尾
        \b               ->     单词边界
        \B               ->     非单词边界
        \A               ->     输入的开头
        \G               ->     上一个匹配的结尾
        \Z               ->     输入的结尾，仅用于最后的结束符
        \z               ->     输入的结尾

4.Greedy 数量词

        Greedy 数量词
        X?               ->      X,一次 或者  一次也没有
        X*               ->      X,零次 或者 多次
        X+               ->      X,一次 或者 多次
        X{n}             ->      X,恰好n次
        X{n,}            ->      X,至少n次
        X{n,m}           ->      X,至少n次，不超过m次

5.组和捕获

        组和捕获
        捕获组可以通过从左到右计算其开括号来编号,在表达式 ((A)(B(C))) 中
        $1    =	((A)(B(C)))
        $2    = 	\A
        $3    =	(B(C))
        $4    =	(C)

6.常见操作

        正则表达式对字符串的常见操作
        1.匹配
               使用String类中的matches方法

        2.切割
               使用String类中的split方法

        3.替换
                使用String类中的replaceAll方法

        4.获取
               1.使用Pattern 将正则表达式封装成对象
               2.通过正则对象Matcher获取匹配器对象
               3.使用调用模式对匹配器进行匹配操作
                 3.1 matches   方法尝试  将整个输入序列    与 该模式匹配
                 3.2 lookingAt 方法尝试  将输入序列从头开始 与 该模式匹配
                 3.3 find      方法扫描  将输入序列以查找   与 该模式匹配的下一个子序列

举列:

        /*
         1.匹配手机号码
            规则：第一位必须要1，第二位为3，5，8，第四位到第十一位为任意的数字
         */
        String tel="13000000000";
        String tel_regex="1[358]\\d{9}";
        System.out.println(tel+":"+tel.matches(tel_regex));

        /*
         2.切割 "."
            如果切割" " 出现了多个空格 采用 str.split(" +")
        */
        String str="神奇的我.神奇的他.神奇的她";
        String[] strs=str.split("\\.");
        for (String s:strs
             ) {
            System.out.println(s);
        }

        /*
            3.如果切割"ttt"或者"pppp" 类似这种叠词 （3个字符及以上）
         */
        String str2="神奇的我ttt神奇的他pppp神奇的她";
        String[] strs2=str2.split("(.)\\1{2,}");
        for(String s:strs2)
        {
            System.out.println(s);
        }

        /*
           4.将里面abc全部替换成ABC
        */
        String str4="abclsadabc,sad,abc,sadsad,s,,,a,b,c";
        String str4_regex="abc";
        String str4_replace="ABC";
        String str5;
        str5=str4.replaceAll(str4_regex,str4_replace);
        System.out.println(str5);

        /*
            5.获取3个小写字母组成的单词
         */
        String str3="ab abc sh,asd,fsas,fdsf, asd  sads a sb";
        String str3_regex="\\b[a-z]{3}\\b";
        //1.使用Pattern 将正则表达式封装成对象
        Pattern p=Pattern.compile(str3_regex);
        //2.通过正则对象Matcher获取匹配器对象
        Matcher m=p.matcher(str3);
        //3.使用调用模式对匹配器进行匹配操作
        while(m.find())
        System.out.println(m.group());

        /*
             6. 对ip地址提取出来排序
         */
        String ip="192.168.1.101/2.2.2.2, 1192.168.1.1  ... 127.0.0.1 .... 1.1.1.1";
        String ip_regex="(\\d{1,3}\\.){3}\\d{1,3}";
        TreeSet<String> ips=new TreeSet<String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //分割
                String [] oo1=o1.split("\\.");
                String [] oo2=o2.split("\\.");
                int i=0;
                while((oo1[i].compareTo(oo2[i]))==0) if(i<=2) i++; else break;
                Integer ooo1=Integer.parseInt(oo1[i]);
                Integer ooo2=Integer.parseInt(oo2[i]);
                return ooo1.compareTo(ooo2);
            }
        });
        Pattern p2=Pattern.compile(ip_regex);
        Matcher m2=p2.matcher(ip);
        while(m2.find())
        {
            ips.add(m2.group());
        }
        for(String ipss:ips)
        {
            System.out.println(ipss);
        }

        /*
            7.对每个超过3个字母的单词 添加小括号
         */
        String str6="ab abc sh,asd,fsas,fdsf, asd  sads a sb";
        String str7=str6.replaceAll("([a-z]{3,})","($1)");
        System.out.println(str7);

/*
            8.对电子邮件进行校验
         */
        String[] malls={"abcd@sina.com.cn","aa@","1232@qq..com","abc@sohu.com","aaa@edu.com"};
        String mall_regex="\\w+(\\w\\.)*@\\w+(\\.\\w{2,3}){1,3}";
        int i=0;
        for(String mall:malls)
        System.out.println(mall+": "+mall.matches(mall_regex));