Java基础笔记（正则表达式）

21 正则表达式

• 基本介绍：

  用某种模式去匹配字符串的一个公式

• 底层实现：⭐️

  

  public class RegTheory {
      public static void main(String[] args) {
  
          String content = "1998年12月8日，第二代Java平台的企业版J2EE发布。1999年6月，Sun公司发布了" +
                  "第二代Java平台（简称为Java2）的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型" +
                  "版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2平台的" +
                  "标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2平台的企业版），应" +
                  "用3443于基于Java的应用服务器。Java 2平台的发布，是Java发展过程中最重要的一个" +
                  "里程碑，标志着Java的应用开始普及9889 ";
          //目标：匹配所有四个数字
          //说明
          //1. \\d 表示一个任意的数字
          String regStr = "(\\d\\d)(\\d\\d)";
          //2. 创建模式对象[即正则表达式对象]
          Pattern pattern = Pattern.compile(regStr);
          //3. 创建匹配器
          //说明：创建匹配器matcher， 按照 正则表达式的规则 去匹配 content字符串
          Matcher matcher = pattern.matcher(content);
  
          //4.开始匹配
          /**
           *
           * matcher.find() 完成的任务 （考虑分组）
           * 什么是分组，比如  (\d\d)(\d\d) ,正则表达式中有() 表示分组,第1个()表示第1组,第2个()表示第2组...
           * 1. 根据指定的规则 ,定位满足规则的子字符串(比如(19)(98))
           * 2. 找到后，将 子字符串的开始的索引记录到 matcher对象的属性 int[] groups;
           *    2.1 groups[0] = 0 , 把该子字符串的结束的索引+1的值记录到 groups[1] = 4
           *    2.2 记录1组()匹配到的字符串 groups[2] = 0  groups[3] = 2
           *    2.3 记录2组()匹配到的字符串 groups[4] = 2  groups[5] = 4
           *    2.4.如果有更多的分组.....
           * 3. 同时记录oldLast 的值为 子字符串的结束的 索引+1的值即35, 即下次执行find时，就从35开始匹配
           *
           * matcher.group(0) 分析
           *
           * 源码:
           * public String group(int group) {
           *         if (first < 0)
           *             throw new IllegalStateException("No match found");
           *         if (group < 0 || group > groupCount())
           *             throw new IndexOutOfBoundsException("No group " + group);
           *         if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
           *             return null;
           *         return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
           *     }
           *  1. 根据 groups[0]=31 和 groups[1]=35 的记录的位置，从content开始截取子字符串返回
           *     就是 [31,35) 包含 31 但是不包含索引为 35的位置
           *
           *  如果再次指向 find方法.仍然安上面分析来执行
           */
          while (matcher.find()) {
              //小结
              //1. 如果正则表达式有() 即分组
              //2. 取出匹配的字符串规则如下
              //3. group(0) 表示匹配到的子字符串
              //4. group(1) 表示匹配到的子字符串的第1组字串
              //5. group(2) 表示匹配到的子字符串的第2组字串
              //6. ... 但是分组的数不能越界.
              System.out.println("找到: " + matcher.group(0));
              System.out.println("第1组()匹配到的值=" + matcher.group(1));
              System.out.println("第2组()匹配到的值=" + matcher.group(2));
  
  
          }
      }
  }
  

21.1 基本语法

• 基本介绍：

  如果要想灵活的运用正则表达式，必须了解其中各种元字符的功能，元字符从功能上大致分为：

  1. 限定符
  2. 选择匹配符
  3. 分组组合和反向引用符
  4. 特殊字符
  5. 字符匹配符
  6. 定位符

• 转义符 //

  需要用到转义符号的字符有以下：.*+()$/\[]^{}

• 字符匹配符：

  

• 选择匹配符：

  

• 限定符：

  

• 定位符：

  

21.2 分组、捕获、反向引用

• 分组：

  我们可以用圆括号组成个比较复杂的匹配模式，那么一个圆括号的部分我们可以看作是一个子表达式/一个分台品

  

• 捕获：

  把正则表达式中子表达式/分组匹配的内容，保存到内存中以数字编号或显式命名的组里，方便后面引用，从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。组O代表的是整个正则式

• 反向引用：

  圆括号的内容被捕获后，可以在这个括号后被使用，从而写出-一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以是在正则表达式内部，也可以是在正则表达式外部，内部反向引用 11分组号，外部反向引用 ＄分组号

  public class RegExp13 {
      public static void main(String[] args) {
          String content = "我....我要....学学学学....编程java!";
  
          //1. 去掉所有的.
  
          Pattern pattern = Pattern.compile("\\.");
          Matcher matcher = pattern.matcher(content);
          content = matcher.replaceAll("");
  
   //       System.out.println("content=" + content);
  
          //2. 去掉重复的字  我我要学学学学编程java!
          // 思路
          //(1) 使用 (.)\\1+
          //(2) 使用 反向引用$1 来替换匹配到的内容
          // 注意：因为正则表达式变化，所以需要重置 matcher
  //        pattern = Pattern.compile("(.)\\1+");//分组的捕获内容记录到$1
  //        matcher = pattern.matcher(content);
  //        while (matcher.find()) {
  //            System.out.println("找到=" + matcher.group(0));
  //        }
  //
  //        //使用 反向引用$1 来替换匹配到的内容
  //        content = matcher.replaceAll("$1");
  //        System.out.println("content=" + content);
  
          //3. 使用一条语句 去掉重复的字  我我要学学学学编程java!
          content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
  
          System.out.println("content=" + content);
      }
  }
  

21.3 常用类

21.3.1 Pattern

• 基本介绍：

  pattern 对象是一个正则表达式对象。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，调用其公共静态方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第个参数

• 例：

  public class PatternMethod {
  
      public static void main(String[] args) {
          String content = "hello abc hello, 韩顺平教育";
          //String regStr = "hello";
          String regStr = "hello.*";
  
          boolean matches = Pattern.matches(regStr, content);
          System.out.println("整体匹配= " + matches);
      }
  }
  

21.3.2 Matcher

• 基本介绍：

  Matcher 对象是对输入字符串进行解释和匹配的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的matcher 方法来获得一个 Matcher 对象

  

• 例：

  public class MatcherMethod {
      public static void main(String[] args) {
          String content = "hello edu jack hspedutom hello smith hello hspedu hspedu";
          String regStr = "hello";
  
          Pattern pattern = Pattern.compile(regStr);
          Matcher matcher = pattern.matcher(content);
          while (matcher.find()) {
              System.out.println("=================");
              System.out.println(matcher.start());
              System.out.println(matcher.end());
              System.out.println("找到: " + content.substring(matcher.start(), matcher.end()));
          }
  
          //整体匹配方法，常用于，去校验某个字符串是否满足某个规则
          System.out.println("整体匹配=" + matcher.matches());
  
          //完成如果content 有 hspedu 替换成 韩顺平教育
          regStr = "hspedu";
          pattern = Pattern.compile(regStr);
          matcher = pattern.matcher(content);
          //注意：返回的字符串才是替换后的字符串 原来的 content 不变化
          String newContent = matcher.replaceAll("韩顺平教育");
          System.out.println("newContent=" + newContent);
          System.out.println("content=" + content);
  
      }
  }
  

21.3.3 PatternSyntaxException

• 基本介绍：

  PatternSyntaxException是一个非强制异常类，他表示一个正则表达式模式中的语法错误