欧洲冠军联赛客户端首页-Linux Shell 正则剖明式
你的位置:欧洲冠军联赛客户端首页 > 网络技术 > Linux Shell 正则剖明式
Linux Shell 正则剖明式
发布日期:2022-08-07 16:46    点击次数:81
 简介

正则剖明式(regular expression)形貌了一种字符串成家的情势(pattern),可以或许用来查抄一个串是否含有某种子串、将成家的子串替代或许从某个串中取出吻合某个条件的子串等。

经常使用正则剖明式

经常使用字符

通俗字符

通俗字符次要解说下列内容,并举例分化

 

//        String regStr = "[a-z]";//成家a-z中肆意一个字符  //        String regStr = "[A-Z]";//成家A-Z中任何一个字符  //        String regStr = "abc";//成家字符串abc  //        String regStr = "(?i)abc";//成家字母abc不判别大小写  //        String regStr = "[0-9]";//成家0-9任何一个字符  //        String regStr = "[^0-9]";//成家不是0-9中的任何一个字符  //        String regStr = "[^0-9]{2}";//成家2个不是0-9的字符  //        String regStr = "\\d";//成家任何一个数字字符,等价于[0-9]  //        String regStr = "\\D";//成家任何一个非数字字符,等价于[^0-9]  //        String regStr = "\\w";//成家任何一个数字、字母、下划线,等价于[0-9a-zA-Z_]  //        String regStr = "\\W";//成家任何一个除了数字、字母、下划线,等价于[^0-9a-zA-Z_]  //        String regStr = "\\s";//成家任何一个空字符  //        String regStr = "\\S";//成家任何一个非空字符  //        String regStr = "ab|cd";//抉择成家符,成家字符串ab或许cd 

1) String regStr = "[a-z]";//成家a-z中肆意一个字符 

@Test  public void test1() {         String str = "abc2021";         String regStr = "[a-z]";         Pattern compile = Pattern.compile(regStr);         Matcher matcher = compile.matcher(str);         while(matcher.find()){             System.out.println("成家到的数据为:"+matcher.group(0));         }   } 

终局展现

2) String regStr = "[A-Z]";//成家A-Z中任何一个字符 

@Test  public void test2(){      String str = "ABCabc2021";      String regStr = "[A-Z]";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

3)String regStr = "abc";//成家字符串abc 

@Test  public void test2(){      String str = "ABCabc2021";      String regStr = "abc";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

4)String regStr = "(?i)abc";//成家字母abc不判别大小写 

@Test  public void test2(){      String str = "ABCabc2021";      String regStr = "(?i)abc";     Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

5) String regStr = "[0-9]";//成家0-9任何一个字符 

@Test  public void test2(){      String str = "ABCabc2021";      String regStr = "[0-9]";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

6) String regStr = "[^0-9]";//成家不是0-9中的任何一个字符 

@Test  public void test2(){      String str = "ABCabc2021";      String regStr = "[^0-9]";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

限制符 
/**   * 限制符   *  *:默示出现肆意次数,0次或许n次,如(abc)*默示abc出现0次或许屡次   *  +:默示出现起码1次或许n次,如(abc)+默示abc出现1次或许屡次   *  ?:默示出现起码0次或许1次,如abc?默示c出现0次或许1次   *  {n}:默示出现n次,如[0-9]{2},默示成家2次数字   *  {n,}默示起码出现n次,如[0-9]{3,}默示成家起码3次数字   *  {n,m}默示出现起码n次,至多m次,如[0-9]{2,4}默示成家次数2-4次数字   */ 

1) *:默示出现肆意次数,0次或许n次 

@Test  public void test2(){      String str = "zypabcabc2021";      String regStr = "zyp(abc)*";      Pattern compile = Pattern.compile(regStr);     Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

2)+:默示出现起码1次或许n次,如(abc)+默示abc出现1次或许屡次 

@Test  public void test2(){      String str = "zypabc2021";      String regStr = "zyp(abc)+";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

3)?:默示出现起码0次或许1次,如abc?默示c出现0次或许1次 

@Test  public void test2(){      String str = "zyp2021";      String regStr = "zyp(abc)?";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

4){n}:默示出现n次,如[0-9]{2},默示成家2次数字 

@Test  public void test2(){      String str = "zyp2021";      String regStr = "[0-9]{2}";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

5){n,}默示起码出现n次,如[0-9]{3,}默示成家起码3次数字 

@Test  public void test2(){      String str = "zyp2021";      String regStr = "[0-9]{2,}";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));    }  } 

终局展现

6){n,m}默示出现起码n次,至多m次,如[0-9]{2,4}默示成家次数2-4次数字 

@Test  public void test2(){      String str = "zyp2021";      String regStr = "[0-9]{2,网络技术4}";      Pattern compile = Pattern.compile(regStr);     Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

定位符 
/**   * 定位符   * ^:默示字符串以什么扫尾的意义。如:有一个字符串123abc,正则为^[0-9]+[a-z]*(必须已数字扫尾),则能告成成家上。假定字符串为a123abc则成家不上   * $:默示字符串以什么终止的意义。如:有一个字符串123abc,正则为^[0-9]+[a-z]+$(默示以数字扫尾,字母扫尾)则能告成成家上。假定字符串为a123abc1则成家不上   * \\b:默示边际成家(字符串的扫尾或许空格当前)。有一个字符串abc123abc,正则为abc\\b,成家到的为最后的那个abc   * \\B:与\\b相反   */ 

1) ^:默示字符串以什么扫尾的意义 

@Test  public void test2(){      String str = "2021zyp";      String regStr = "^[0-9]+";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

2) $:默示字符串以什么终止的意义 

@Test  public void test2(){      String str = "2021zyp";     String regStr = "[0-9]$";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){         System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

没有成家到,因为要以数字终止

3) \\b:默示边际成家(字符串的扫尾或许空格当前) 

@Test  public void test2(){      String str = "zyp2021zyp";      String regStr = "zyp\\b";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));     }  } 

成家到的是最后一个“zyp”

4) \\B:与\\b相反 

@Test  public void test2(){      String str = "zyp2021zyp";      String regStr = "zyp\\B";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));    }  } 

成家到的是第一个“zyp”

分组 
/**   * 分组:可分为捕获分组和非捕获分组   * 1.捕获分组:   * 1)如(\\d\\d)(\\d\\d)默示成家4位数字,假定字符串位2021abcd,   * 我们经由过程matcher.group(0)失去2021   * 经由过程matcher.group(1)失去20   * 经由过程matcher.group(2)失去21   * 因而可知()起到分组的浸染   *   * 2)如(?<a1>\\d\\d)(?<a2>\\d\\d)默示成家4位数字,假定字符串位2021abcd,   * 我们经由过程matcher.group(0)失去2021   * 经由过程matcher.group(1)失去20,还可以或许经由过程matcher.group(a1)失去20   * 经由过程matcher.group(2)失去21,还可以或许经由过程matcher.group(a2)失去21   * 因而可知()起到分组的浸染   *   * 2.非捕获分组:不克不迭经由过程group(1)或许group(2)取得值   *  1)如20(?:20|21|22)默示成家2020|2021|2022   *  2) 如20(?=20|21|22)默示成家2020或2021或2022中的20   *  3)如20(?!20|21|22)默示成家不成家2020或2021或2022中的20,成家另外20   *   */ 
捕获分组

1)如(\\d\\d)(\\d\\d)默示成家4位数字,假定字符串为2021abcd, 

@Test  public void test2(){      String str = "2021abcd";      String regStr = "(\\d\\d)(\\d\\d)";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("matcher.group(0):"+matcher.group(0));          System.out.println("分组一:matcher.group(1):"+matcher.group(1));          System.out.println("分组二:matcher.group(2):"+matcher.group(2));      }  } 

终局展现

结论:因而可知()会将正则分组,并按按次给出编号,从1起头

2) (?<a1>\\d\\d)(?<a2>\\d\\d)默示成家4位数字,假定字符串位2021abcd 

@Test  public void test2(){      String str = "2021abcd";      String regStr = "(?<a1>\\d\\d)(?<a2>\\d\\d)";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("matcher.group(0):"+matcher.group(0));          System.out.println("分组一:matcher.group(1):"+matcher.group(1));          System.out.println("分组二:matcher.group(2):"+matcher.group(2));          System.out.println("分组名a1:matcher.group(1):"+matcher.group("a1"));          System.out.println("分组名a2:matcher.group(2):"+matcher.group("a2"));      }  } 

终局展现

结论:因而可知()除了能将正则分组,还能按按次给出编号,从1起头。还可以或许给分组取名字,并痛处名字取得对应成家的值

非捕获分组

1)如20(?:20|21|22)默示成家2020|2021|2022 

@Test  public void test2(){      String str = "2021a2022B2023";      String regStr = "20(?:20|21|22)";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

终局展现

2)如20(?=20|21|22)默示成家2020或2021或2022中的20 

@Test  public void test2(){      String str = "2021a2022B2023";      String regStr = "20(?=20|21|22)";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      }  } 

这里成家到的20,为2021和2022中的20

3)如20(?!20|21|22)默示成家不成家2020或2021或2022中的20,成家另外20 

@Test  public void test2(){      String str = "2021a2022B2023";      String regStr = "20(?!20|21|22)";      Pattern compile = Pattern.compile(regStr);      Matcher matcher = compile.matcher(str);      while(matcher.find()){          System.out.println("成家到的数据为:"+matcher.group(0));      } } 

这里成家到的20为2023中的20

反向引用 
/**   * 反向引用   * 假定我们要找到一个字符串中央断4位威数字,并且第一位和第4位要沟通,第二位和第三位沟通。   * 这岁月我们运用反向引用就很俭朴   * 反向引用的外部用法:\\n个中n代表分组号,如:字符串12345678870008,正则为(\\d)(\\d)\\2\\1   * 反向引用的外部用法:$n个中n代表分组号   */ 

字符串12345678870008,正则为(\\d)(\\d)\\2\\1 

@Test      public void test2(){          String str = "12345678870008";          /**           * 第一个(\\d)会分派的组为1           * 第2个(\\d)会分派的组为2           * \\2:默示引用组2的值,因而2和3的值就会沟通           * \\1:默示引用组1的值,因而1和4的值会沟通           */          String regStr = "(\\d)(\\d)\\2\\1";          Pattern compile = Pattern.compile(regStr);          Matcher matcher = compile.matcher(str);          while(matcher.find()){              System.out.println("成家到的数据为:"+matcher.group(0));        }      } 

终局展现 

 



相关资讯