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

正则表达式(java 版)的理解一个特殊字符 ‘\’在 java 中有一个特殊的字符,那就是使用 \ (反斜线)后面再添加一个字符,我们叫转义字符(escape charact

大家好,欢迎来到IT知识分享网。

一个特殊字符 ‘\’

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

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

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

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

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

String 中的 ‘\’

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

@Test
public void testBackSlash() {

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

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

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

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

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

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

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

System.out.println("============demo8============");
//四个反斜线代表一个反斜线 demo8
String normalJson = json2.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 文档:

[https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)

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

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

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

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

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

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

@Test
public void patternMethods() {

System.out.println("===demo1:compile(String regex)===");
//demo1 compile(String regex)
Pattern p1 = Pattern.compile("\\d+");
System.out.println(p1.toString());

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

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

//demo4 pattern() and toString()
System.out.println("===demo4:pattern() and toString()===");
System.out.println(p2.pattern());
System.out.println(p2.toString());

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

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

System.out.println("===demo7:quote(String)===");
//quote(String)
String s = Pattern.quote("\\d{3}");
System.out.println(s);
boolean test1 = Pattern.matches(s, "456");
boolean test2 = Pattern.matches(s, "\\d{3}");
System.out.println(test1);
System.out.println(test2);

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

结果如下:

正则表达式(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 p1 = Pattern.compile(":");
String[] test0 = p1.split(s, 1);//["boo:and:foo"]
String[] test1 = p1.split(s, 2);//{ "boo", "and:foo" }
String[] test2 = p1.split(s, 5);//{ "boo", "and", "foo" }
String[] test3 = p1.split(s, -2);//{ "boo", "and", "foo" }

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

//直接分割成数据流,便于使用集合类进行数据的操作
Stream stream = p1.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[] test0 = p1.split(s, 1);//["boo:and:foo"]

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

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

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

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

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

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

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

public String[] split(CharSequence input)

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

Stream stream = p1.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{3}).)(\\w{2})");
Matcher m = p.matcher("hello987xworld456yhltest");
int groupCount = m.groupCount();
System.out.println("==="+ "groupCount:"+groupCount+"===");
int findCount = 0 ;
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(0));
for (int i = 1; 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{3}");
Matcher m1 = p.matcher("hello076world123test");
m1.find();
System.out.println("===m1===");
System.out.println(m1.group());
m1.find();
System.out.println(m1.group());

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

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

System.out.println("===m2 lookingAt()===");
m2.lookingAt();
System.out.println(m2.group());
m2.lookingAt();
System.out.println(m2.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{3}");
Matcher m1 = p.matcher("1345");
System.out.println(m1.matches());//false

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

Matcher m3 = p.matcher("134345");
System.out.println(m3.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 p1 = Pattern.compile("a*b");
Matcher m1 = p1.matcher("aabfooaabfooabfoob");
String s = m1.replaceAll("-");
System.out.println(s);//-foo-foo-foo-

Pattern p2 = Pattern.compile("cat");
Matcher m2 = p2.matcher("one cat two cats in the yard");
StringBuffer sb = new StringBuffer();
while (m2.find()) {
m2.appendReplacement(sb, "dog");
}
System.out.println(sb.toString());
m2.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 也有列举说明:

[https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)

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

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

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

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

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

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

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

//(?<!X)
Pattern p5 = Pattern.compile("(?<!zempty|boys)handsome");
Matcher m8 = p5.matcher("boyshandsome");
while (m8.find()) {//false
System.out.println(m8.group());
}
Matcher m9 = p5.matcher("everyonehandsome");
while (m9.find()) {
System.out.println(m9.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 。

。。。。

免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://yundeesoft.com/59820.html

(0)
上一篇 2024-05-09 07:14
下一篇 2024-05-09 11:26

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注

关注微信