正则表达式

一、正则表达式的特点：

好处：可以简化对字符串的复杂操作 弊端：符号定义越多，正则越长，阅读性越差。
主要用途：
* 1，匹配
* 其实就是使用string类的matches()方法
* 2，切割
* 其实就是使用string类的split()方法
* 3，替换
* 其实就是使用string类的replaceAll()方法
* 4，获取

二、常用操作字符

（1）字符

    x 字符 x

    \\ 反斜线字符

    \0n 带有八进制值 0 的字符 n (0<= n <= 7)

    \0nn 带有八进制值 0 的字符 nn (0<= n <= 7)

    \0mnn 带有八进制值 0 的字符 mnn（0 <= m<= 3、0 <= n <= 7）

    \xhh 带有十六进制值 0x 的字符 hh

    \uhhhh 带有十六进制值 0x 的字符 hhhh

    \t 制表符 ('\u0009')

    \n 新行（换行）符 ('\u000A')

    \r 回车符 ('\u000D')

    \f 换页符 ('\u000C')

    \a 报警 (bell) 符 ('\u0007')

    \e 转义符 ('\u001B')

    \cx 对应于 x 的控制符



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



（3）预定义字符类

    . 任何字符（与行结束符可能匹配也可能不匹配）

    \d 数字：[0-9]

    \D 非数字： [^0-9]

    \s 空白字符：[ \t\n\x0B\f\r]

    \S 非空白字符：[^\s]

    \w 单词字符：[a-zA-Z_0-9]

    \W 非单词字符：[^\w]



（4）边界匹配器

    ^ 行的开头

    $ 行的结尾

    \b 单词边界

    \B 非单词边界

    \A 输入的开头

    \G 上一个匹配的结尾

    \Z 输入的结尾，仅用于最后的结束符（如果有的话）

    \z 输入的结尾



（5）Greedy数量词

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

    X* X，零次或多次

    X+ X，一次或多次

    X{n} X，恰好 n 次

    X{n,} X，至少 n 次

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

三、案例演示

1，匹配

（1）匹配手机号码是否正确

    /**
     * 演示匹配
     */
    public static void test1(){
        //匹配手机号码是否正确
        String tel="13126674217";
        String regex="1[358][0-9]{9}";//或者 String regex="1[358]\\d{9}";
        boolean matches = tel.matches(regex);
        System.out.println(matches);

    }

（2）对邮箱进行校验


    /**
     * 对邮箱进行校验
     */
    private static void test2() {
        String str="adb1@sina.com.cn";
        String regex="[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-z]{1,3})+";
        boolean matches = str.matches(regex);
        System.out.println(matches);
    }

2，切割

（1）按照空格进行切割

    public static void test1(){
      String str="张三    小强   周六";
      String regex=" +";//出现一次或多次
      String[] split = str.split(regex);
       for (int i = 0; i < split.length; i++) {
           System.out.println(split[i]);
       }
    }


（2）按照 . 进行切割

   public static void test2(){
    String str="张三  .   小强  .  周六";
    String regex="\\.+";
    String[] split = str.split(regex);
    for (int i = 0; i < split.length; i++) {
        System.out.println(split[i].trim());
    }
  }

（3）按照有重复字符的进行切割

    public static void test3(){
        String str="zhangsanmmmmmmmzhaosittttttxiaohong";
        String regex="(.)\\1+";//(.)：代表组  \\1：代表组的序号
        String[] split = str.split(regex);
        for (int i = 0; i < split.length; i++) {
        System.out.println(split[i].trim());
       }
    }

3，替换

（1）替换重复字符（最后输出结果：zhangsan zhaosi xiaohong）

  public static void test1(){
    String str="zhangsanmmmmmmmmmmmzhaositttttttttttxiaohong";
      String regex="(.)\\1+";//第一组  ()：代表组  \\1：代表组的序号
      //$1 代表：获取已有正则表达式的第一组作为参数
      String s = str.replaceAll(regex,"$1 ");
      System.out.println(s);
  }

（2）把手机号码13126674217 替换成131****4217 这种格式

  public static void test2(){
        String str1="13126674217";//131****4217
        String regex="(\\d{3})\\d{4}(\\d{4})";
        //$n 代表：获取已有正则表达式的第n组作为参数  n代表从1开始的整数
        String s = str1.replaceAll(regex, "$1***$2");
        System.out.println(s);
   }


（3）治疗口吃

    private static void test3() {
        String str="我我....我我.....要要要.....要学学学编程程程....";
        String regex="\\.+";
        //替换所有.
        String s = str.replaceAll(regex, "");
       //第一组的任意字符出现1次或者多次
        String regex2="(.)\\1+";
        String s1 = s.replaceAll(regex2, "$1");
        System.out.println(s1);
    }

4、获取

  /**
    * 演示获取
    */
   private static void test4() {
       String str="ming tian bu yong shang ke le !";
       String regx="[a-z]{4} ";
       Pattern pattern=Pattern.compile(regx);
       Matcher matcher = pattern.matcher(str);
       while (matcher.find()) {
           System.out.println(matcher.group());
       }
   }