正则表达式(java 版)的理解

Java
266
0
0
2023-09-18

一个特殊字符 ‘’


在 java 中有一个特殊的字符,那就是使用 ( 反斜线 )后面再添加一个字符,我们叫 转义字符 (escape character),比如 n 表示的是换号符号,并不是单纯的一个 n 字符了。

正则表达式(java 版)的理解

那 (反斜线)用来做转义字符了,那么程序就是要输出一个 (反斜线)怎么处理呢?

那就是再使用一个 (下划线) ,用来说明告诉程序,接下来的 并不是用来转义字符的。

下面我们看看 String 类 中关于 (反斜线)的一些使用;

String 中的 ‘’

我们先来看看下面的代码:

 @Test
public  void  testBackSlash() {

    System.out.println("============demo============");
    //输出一个 单引号 字符 demo1
    char singleQuotes = ''';
    System.out.println(singleQuotes);

    System.out.println("============demo============");
    //输出一个双引号 demo
    String doubleQuotes = """;
    System.out.println(doubleQuotes);

    System.out.println("============demo============");
    //添加转义字符在 字符串 当中 demo3
    String hi = "你好nt棒";
    System.out.println(hi);

    System.out.println("============demo============");
    //输出一个  demo
    String backSlash = "";
    System.out.println(backSlash);

    System.out.println("============demo============");
    //windows系统常用文件路径,需要多添加一个  demo
    String path = "C:Windows System32 cmd.exe";
    System.out.println(path);

    System.out.println("============demo============");
    //输出一个  json  demo6
String json = "{"name":"zempty"}";
    System.out.println(json);

    System.out.println("============demo============");
    //数据带有反斜线的 json demo
String json = "{"name":"zempty"}";
    System.out.println(json);

    System.out.println("============demo============");
    //四个反斜线代表一个反斜线 demo
    String normalJson = json.replaceAll("\","");
    System.out.println(normalJson);
} 

你能回到以上 8 个示例的输出结果吗?如果可以,那么你对 java 当中转义字符 和反转义 应该很清楚了,结果如下:

正则表达式(java 版)的理解

在 java 语言当中 ‘ (单引号)用来表示字符,“ (双引号)用来表示字符串,所以如何输出一个单引号字符和一个双引号呢?所以在 java 当中就有了转义字符 来帮忙了。

如何反转义呢?那就使用两个 ,上面示例 4 中两个 可以输出一个 。

在示例 5 中大家熟知的 windows 系统中的文件路径通常就需要一个 ,那么使用两个 就可以防止发生转义,正常的输出一个 。

在示例 7 中使用了三个 怎么理解呢? 前两个会输出一个 , 最后一个 是转义字符,“ 是输出一个 “ 。

** 在示例 8 中的四个 \ 表示一个 怎么理解呢?尝试解释一下,查询了解一下…… **

java 中的 正则表达式 Pattern

在 java 中有这样一个包,java.util. regex 这个包提供给我们方便使用正则表达式, Pattern 类是干嘛用的呢?

正则表达式就是一类字符串,这类字符串符合特定的规则而已,比如:** [0-9]d{5} ** 就是匹配六位数字。

java 中 Pattern 就是正则表达式,通过 Pattern.compile(String regex) 来创建一个正则表达式实例,正则表达式是一个有规则的字符串,在 java 中定义一个有规则的字符串(正则表达式)用 Pattern 来表示。

Pattern 类文档中列举了许多正则表达式的规则,正则表达式忘记了也可以查询该类的 API 文档:

[

上文的一个问题 :** 在上文的示例 8 中的四个 \ 表示一个 怎么理解呢? **

我们看一下 String 类的 replaceAll 方法,第一个参数是 regex 正则表达式,我们就大致可以明白:

1. 在 java 中两个反斜线 输出一个反斜线 ,四个反斜线就会处理成两个反斜线 。

2. 再由正则表达式处理上述结果的两个反斜线 ,这里最终结果两个反斜线又解释成了一个反斜线 。

所以在 java 当中如果需要通过正则表达式匹配一个反斜线,那么就需要四个反斜线 \ 。

下面来研究一下 Pattern 这个类:

 @Test
public void patternMethods() {

    System.out.println("===demo:compile(String regex)===");
    //demo compile(String regex)
    Pattern p = Pattern.compile("d+");
    System.out.println(p.toString());

    System.out.println("===demo:compile(String regex,int flags)===");
    //demo compile(String regex,int flags)
    Pattern p = Pattern.compile("[AbC]", Pattern.CASE_INSENSITIVE);
    System.out.println(p.toString());
    Matcher m = p.matcher("hat");
    while (m.find()) {
        System.out.println(m.group());
    }

    System.out.println("===demo:compile(String regex,int flags)===");
    //demo flags()
    System.out.println(p.flags());

    //demo pattern() and toString()
    System.out.println("===demo:pattern() and toString()===");
    System.out.println(p.pattern());
    System.out.println(p.toString());

    System.out.println("===demo:matcher(CharSequence)===");
    //matcher(CharSequence)
    Matcher m = p2.matcher("hat");
    System.out.println(m);

    System.out.println("===demo:matches(String regex,CharSequence)===");
    //matches(regex,CharSequence)
 boolean  result = Pattern.matches("w{1,10}", "helloworld");
    System.out.println(result);

    System.out.println("===demo:quote(String)===");
    //quote(String)
String s = Pattern.quote("d{}");
    System.out.println(s);
    boolean test = Pattern.matches(s, "456");
boolean test = Pattern.matches(s, "d{3}");
    System.out.println(test);
    System.out.println(test);

    System.out.println("===demo:asPredicate()===");
    //asPredicate
    Pattern p = Pattern.compile("hello");
    boolean test = p3.asPredicate().test("glksahgaghello");
    System.out.println(test);
} 

结果如下:

正则表达式(java 版)的理解

以上方法中 compile 方法用来编译正则表达式(创建 Pattern 示例),compile 方法提供了两个方法,带有两个参数的 int flag 可以实现不同需求,比如上面示例中的Pattern.CASE_INSENSITIVE 就是表示正则表达式匹配字符串的时候不用区分大小写; flags ()用来输出 Pattern 的 flag 。

pattern() 和 toString () 方法效果相同,就是输出一个正则表达式。

macher 方法是用来生成一个匹配对象 Matcher ,该类提供了一些获取匹配到的字符串的一些方法,matches 方法是一个 静态方法 ,提供正则表达式和需要匹配的字符串直接获取匹配结果:true 匹配,false 不匹配。

quote 方法直接输出一个文本字符串,这个方法的用处是什么呢?

有时候我们需要正则表达式失效,就是想匹配原字符串,我们可以使用该方法,具体可以参考上面的示例。

asPredicate() 方法获取一个断言,可以判断正则表达式和断言提供的字符串是否有匹配结果。

在 Pattern 类中有这样一个方法 split(CharSequence,int) 这个方法,这个方法很难理解,现在通过示例代码说明:

 @Test
public void PatternSplit() {
    // split(CharSequence,int)
    String s = "boo:and:foo";
    Pattern p = Pattern.compile(":");
    String[] test = p1.split(s, 1);//["boo:and:foo"]
String[] test = p1.split(s, 2);//{ "boo", "and:foo" }
String[] test = p1.split(s, 5);//{ "boo", "and", "foo" }
String[] test = p1.split(s, -2);//{ "boo", "and", "foo" }

    Pattern p = Pattern.compile("o");
    String[] test = p2.split(s,2);//["b", "o:and:foo"]
    String[] test = p2.split(s, 3);//["b", "", ":and:foo"]
    String[] test = p2.split(s, 4);//["b", "", ":and:f", "o"]
    String[] test = p2.split(s, 5);//["b", "", ":and:f", "", ""]
    String[] test = p2.split(s, -1);//["b", "", ":and:f", "", ""]
    String[] test = p2.split(s, 0);//["b", "", ":and:f"]
    // spilt(CharSequence) 和 Split(CharSequence,) 内部调用的是两个参数的方法,limit = 0
    String[] test = p2. split (s);//["b", "", ":and:f"]

    //直接分割成数据流,便于使用集合类进行数据的操作
    Stream stream = p.splitAsStream("hello:world:demo");
 Iterator <String> ss = stream.iterator();
    while (ss.hasNext()) {
        String result = ss.next();
        System.out.println(result);
    }
} 

参考以上示例,分析 split 方法 limit 的参数一下几种情况:

 public String[] split(CharSequence input,int limit) 

1. limit > 0

split 方法返回的是数组,数组的长度不可以超过 limit 的值,limit ≥ 数组的长度才可以,为了满足这个条件因此切割字符串的次数最多是 limit – 1 次。

2. limit < 0

当 limit < 0 ,如果匹配正则表达式就会进行切割切分,匹配多少次切割多少次,数组长度没有限制。

3. limit = 0

如果匹配结果就会进行切割,切割拆分后的结果会舍弃尾部的空字符串,尾部空字符串会被丢弃,数组长度没有限制

特殊案例分析:

 String[] test = p1.split(s, 1);//["boo:and:foo"] 

提供的 limit = 1, 也就是数组长度最大是 1, 因此不会进行切割拆分。

 String[] test = p2.split(s, 3);//["b", "", ":and:foo"] 

从上面的结果可以看出,少了两个 0 ,因此进行切割了两次,因为不间断连续切割,因此中间会有一个空字符串,这样数组的总长度已经等于提供的 limit = 3 ,无法在继续进行切割。

 String[] test = p2.split(s, 5);//["b", "", ":and:f", "", ""] 

limit = 5 , 最多只能进行切割拆分 4 次 ,中间不间断连续切割两次补了一个空字符串,尾部也是不间断连续切割补了一个字符串,最后因为在字符串尾部切割了一次,没有剩余子串,尾部会追加一个空字符串。

 String[] test = p2.split(s, 0);//["b", "", ":and:f"] 

当 limit = 0 的时候,同一个参数的 split 方法效果相同:

 public String[] split(CharSequence input) 

如果切割拆分的尾部有空字符串将会被舍弃。



 Stream stream = p.splitAsStream("hello:world:demo"); 

splitAsStream 方法提供了生成 Stream 流的方法,这样方便我们把拆分后的结果就行流式处理(切割拆分结果同 limit = 0 ,使用一个参数的 split 方法相同),方便集合操作等等。

Matcher 中几个常见方法分析

Matcher 类用来获取匹配结果,Matcher 类中有几个高频常用方法,下面加以说明:

在解释说明 Matcher 类常用方法之前,我们需要理解一个概念,那就是正则表达式中组的概念,正则表达式如何分组,组号怎么理解的,组名又是什么呢?

正则表达式中使用括号来分组,我们可以统计有几个左括号就是有几组,从左边开始算起,组号分别是 1,2,3…..n 。

 (A(B(C))) 

ABC 是第一组,组号是 1 。

BC 是第二组,组号是 2 。

C 是第三组,组号是 3 。

组号 0 表示正则表达式的一个整体,上面也是就是 ABC 。



 @Test
public void groupTest() {
Pattern p = Pattern.compile("((d{}).)(w{2})");
    Matcher m = p.matcher("helloxworld456yhltest");
    int groupCount = m.groupCount();
    System.out.println("==="+ "groupCount:"+groupCount+"===");
    int findCount = ;
    while (m.find()) {
        findCount++;
        System.out.println("==="+"找到第 "+ findCount + " 个匹配");
        System.out.println("==="+"匹配开始索引:"+m.start()+"===");
        System.out.println("==="+"匹配结束索引:" + m.end()+"===");
        System.out.println("==="+"完全匹配结果"+"===");
        System.out.println(m.group());
        System.out.println(m.group());
        for (int i =; i <= groupCount; i++) {
            System.out.println("==="+"第 "+i +" 组"+"===");
            System.out.println(m.group(i));
        }
    }
    System.out.println("==="+"匹配到 "+ findCount + " 个结果"+"===");
} 

上面一段代码正则表达式有几组,每组匹配的是什么?

上面的正则表达式中分 3 组,第一组 d{3}. 在匹配的结果中第一组是 3个数组和任意一个字符;第二组是 d{3} 是 3 个数字;第三组 w{2} 匹配两个字母。

 public int groupCount() 

这个方法用来统计改正则表达式有几组,上面的示例中 groupCount 输出是 3 。

 public boolean find() 

find 方法是找到给定字符串匹配到的正则表达式的结果,上面示例中 m.find() 结果是 true,它的运行机制是从给定的字符串 hello987xworld456yhltest 从头开始匹配正则表达式,找到 9 开始进行匹配,然后 987xwo 中到一个匹配,程序会记录下字符串匹配到的开始索引和结束索引 ;

继续匹配,一直匹配到字符串的结束为止,当匹配到 456yhl 匹配到第二个结果,程序依然会记录第二次匹配到的开始索引和结束索引。

综上所述,上面的示例 m.find () 在 while 循环到中会找到两次匹配结果,第一次匹配结果是:987xwo 返回 true ; 第二次匹配结果是:456yhl 返回 true,findCount 的输出结果是 2 。

 public int start()
public int end() 

start 方法返回值是匹配到结果在字符串中的开始索引,end 方法返回的是匹配到结果在字符串中的结束索引,上面示例中匹配到的第一个结果 987xwo 在给定的字符串中 hello987xworld456yhltest 开始索引是 5,结束索引是 11; 第二个结果 456yhl 开始索引是 14,结束索引是 20 。

 public String group()
public String group(int group) 

group() 方法返回的是正则表达式匹配到的结果,示例中 group()的输出结果分别是 987xwo 和 456yhl , group (0) 和 group() 结果相同都是输出完全匹配结果。

group(int) 方法中的参数是组号,上面示例中正则表达式有三组,第一组匹配的是3个数组和任意一个字符 ,因此在第一次匹配的结果 987xwo 中第一组是 987x,第二组是是 3 个数字 987,第三组是两个字母 wo;同理可分析第二次匹配结果 456yhl 中各组的匹配结果。

依据综上分析,可知上述示例的输出结果:

正则表达式(java 版)的理解

Matcher 类中 reset() 相关方法

 public Matcher reset()
public Matcher reset(CharSequence input)
public boolean lookingAt() 
 @Test
public void reset() {
Pattern p = Pattern.compile("d{}");
    Matcher m = p.matcher("hello076world123test");
    m.find();
    System.out.println("===m===");
    System.out.println(m.group());
    m.find();
    System.out.println(m.group());

    Matcher m = p.matcher("hello076world123test");
    m.find();
    System.out.println("===m reset()===");
    System.out.println(m.group());
    m.reset();
    m.find();
    System.out.println(m.group());

    m.reset("123testdemo345");
    m.find();
    System.out.println("===m reset(CharSequence)===");
    System.out.println(m.group());
    m.find();
    System.out.println(m.group());

    System.out.println("===m lookingAt()===");
    m.lookingAt();
    System.out.println(m.group());
    m.lookingAt();
    System.out.println(m.group());
} 

上述示例说明了 reset 方法的使用规则:

reset 中文意思是重置,在这里是重置匹配的位置,从头开始。

1. 示例中的 m1.find() 会往下寻找匹配,找到匹配后就录匹配的结束位置,当下一次 m1.find() 的时候,会从上次的匹配的结束位置,继续往下匹配。

2. m2.reset() 后会从头开始匹配,在 m2 的第一个例子中,两次的匹配结果相同。

3. 在示例 m2.reset(“123testdemo345”) 当中,m2 重置了要匹配的字符串对象,结果也会从头开始进行结果的匹配。

4. lookingAt() 方法的效果就是从头开始匹配,因此最后一个 lookingAt() 的示例,两次输出的结果是相同的。

正则表达式(java 版)的理解



Matcher 类的 matches() 方法分析:

 public boolean matches() 
 @Test
public void matches() {
Pattern p = Pattern.compile("d{}");
    Matcher m = p.matcher("1345");
    System.out.println(m.matches());//false

    Matcher m = p.matcher("134");
    System.out.println(m.matches());//true
    System.out.println(m.group());//134

    Matcher m = p.matcher("134345");
    System.out.println(m.matches());//false
} 

matches() 匹配的是整个字符串是否匹配正则表达式,比如上面示例当中的正则表达式是要匹配的是 3 个数字,m1 给定的字符串是 1345 四个数字不匹配,m2 符合要求返回true,m3 给定的 134345 给定六个数字依然不匹配,返回 false , matches() 方法需要同 find() 方法区分开来:

1. matches 比配的是整体字符串,整体匹配正则表达式才会返回 true 。

2. find() 是在给定的字符串中从头开始找子串,子串有符合就会返回 true ;如果继续调用 find() 会从匹配的前一个子串的结尾处,继续寻找下去。

更新给定字符串的方法:

 public String replaceAll(String replacement)

public Matcher appendReplacement(StringBuffer sb,
String replacement)

public StringBuffer appendTail(StringBuffer sb) 
 @Test
public void updateString() {
    Pattern p = Pattern.compile("a*b");
    Matcher m = p1.matcher("aabfooaabfooabfoob");
    String s = m.replaceAll("-");
    System.out.println(s);//-foo-foo-foo-

    Pattern p = Pattern.compile("cat");
    Matcher m = p2.matcher("one cat two cats in the yard");
    StringBuffer sb = new StringBuffer();
    while (m.find()) {
        m.appendReplacement(sb, "dog");
    }
    System.out.println(sb.toString());
    m.appendTail(sb);
    System.out.println(sb.toString());
} 

replaceAll 方法是从给定的字符串中找匹配正则表达式的子串,找到后使用replaceAll 方法提供的字符串替换匹配到的子串,上述示示例中正则表达式的意思是匹配 b 在尾部,b 前面有 0 个或者多个 a 的子串,匹配到子串后使用 replaceAll 方法提供的参数字符串替换掉匹配到的子串,示例中 s 的输出结果是 foo-foo-foo- 。

appendReplacement 方法把给定的字符串 one cat two cats in the yard 从头开始匹配正则表达式,如果匹配成功的话,就把匹配到的子串之前的子串追加到 StringBuffer 当中,并把匹配到的子串替换成 appendReplacement 给定的第二个参数字符串继续追加到 StringBuffer 当中 ,该方法的逻辑大致总结如下:** 匹配成功,StringBuffer = 目标子串前面的子串 + 替换参数 **

因此上面示例 while 循环结束以后,输出结果是 one dog two dog 。

appendTail(StringBuffer) 追加尾部没匹配到的子串到 StringBuffer 当中,最终的输出是 one dog two dogs in the yard 。

综上所述关于 Matcher 类的主要功能大致列举完毕…

正则表达式的奇怪写法

能写出一个好的正则表达式是正则表达式最难的地方,有时候看着别人写的正则表达式就是看不懂,这时候我们就要寻求万能的谷歌帮忙了,其实正则表达式的各种表现形式,在 Java 的 Pattern API 也有列举说明:

[

下面列举几个不常用的一些写法:

 (?<name>X)
(?=X)
(?!X)
(?<=X)
(?<!X) 

为了理解上面这个表达式,我们来看看下面的例子:

 @Test
public void testPattern() {
    //给组命名 (?<name>X)
Pattern p = Pattern.compile("(?<hello>d)w{2}");
    Matcher m = p.matcher("testhi");
    while (m.find()) {
        System.out.println(m.group());//hi
        System.out.println(m.group());//23
        System.out.println(m.group("hello"));//
    }

    //(?=X)
    Pattern p = Pattern.compile("zempty(?=handsome|cool)");
    Matcher m = p2.matcher("zemptycool123");
    while (m.find()) {
        System.out.println(m.group()); //zempty
    }
    Matcher m = p2.matcher("zemptyniubi");
    while (m.find()) {//false
        System.out.println(m.group());
    }

    //(?!X)
    Pattern p = Pattern.compile("zempty(?!handsome|cool)");
    Matcher m = p3.matcher("zemptycool");
    while (m.find()) {//false
        System.out.println(m.group());
    }
    Matcher m = p3.matcher("zemptyniubi");
    while (m.find()) {
        System.out.println(m.group());//zempty
    }

    //(?<=X)
    Pattern p = Pattern.compile("(?<=zempty|boys)handsome");
    Matcher m = p4.matcher("boyshandsome");
    while (m.find()) {
        System.out.println(m.group());//handsome
    }
    Matcher m = p4.matcher("everyonehandsome");
    while (m.find()) {//false
        System.out.println(m.group());
    }

    //(?<!X)
    Pattern p = Pattern.compile("(?<!zempty|boys)handsome");
    Matcher m = p5.matcher("boyshandsome");
    while (m.find()) {//false
        System.out.println(m.group());
    }
    Matcher m = p5.matcher("everyonehandsome");
    while (m.find()) {
        System.out.println(m.group());//handsome
    }
} 

前文提到了正则表达式的分组,但是正则表达式的命名没有提到?参考示例 “(?<hello>d3)w{2}” 表示的是匹配三个数字和两个字母的字符串,其中 “(?<hello>3) ” 表示的一个分组,组号是 1, 组名是 hello ,所以参考以上示例可知 m.group(”hello”) 是得到组名为 hello 的字符串。

(?=X) 可以这样理解:

1. 寻找匹配到的正则表达式字符串,其中包含匹配到的 X 子串,X 子串在尾部 ;

2. 去掉尾部匹配到的字符串中是 X 的子串,然后得到结果。

上面示例中的正则表达式是 “zempty(?=handsome|cool)” 表示的的是在含有 zemptyhandsome 或者 zemptycool 的字符串中获取 zempty 这个结果。

(?!X) 可以这样理解:

1. 寻找匹配到的正则表达式字符串其中不包含的 X 子串,不包含的 X 子串在尾部;

2. 去掉尾部匹配字符串中不是 X 的子串,然后得到结果。

上面的示例中 “zempty(?!handsome|cool)” 表示的在含有 zempty 且后面不能包含 handsome 或者 cool 的子字符串中获取 zempty 整个结果。

通常 (?=X) 和 (?!X) 的正则表达式写法就形如 xxxx(?=X) 获取尾部是 X 的 xxxx, 比如示例中 zempty(?=handsome|cool) 就是获取 zempty 这个子字符串,但是条件是只能获取zempty 后面是 handsome 或者 cool 中的 zempty 。

(?<=X) 可以这样理解:

1. 寻找匹配到的正则表达式字符串其中包含匹配到的 X ,X 子串在头部;

2. 去掉头部匹配到的字符串中是 X 的子串,然后得到结果。

上面的示例中的正则表达式 “(?<=zempty|boys)handsome” 表示的是在含有zemptyhandsome 或者 boyshandsome字符串中获取 handsome 这个结果。

(?<!X) 可以这样理解:

1. 寻找匹配到的正则表达式字符串其中不包含的 X 子串 ,不包含的 X 子串在尾部;

2. 去掉头部匹配到的字符串中不是X 的子串,然后得到结果。

上面的示例中的正则表达式 “(?<!zempty|boys)handsome” 表示的是在获取 handsome 这个结果,但是 handsome 前面不能有 zempty 或者 boys 。

通常 (?<=X) 和 (?<!X) 的正则表达式写法是 (?<=X)xxxx 获取头部是 X 的 xxxx,比如示例中的 “(?<=zempty|boys)handsome” 就是获取 handsome 这个子字符串,但是条件是只能获取 handsome 前面是 zempty 或者 boys 的 handsome 。

。。。。