Java中的正则表达式 regex
常用类解析:正则表达式 regex
- 前言
- 一、正则表达式
- 二、匹配规则
- 三、匹配任意字符
- 四、匹配数字
- 五、匹配常用字符
- 六、匹配空格字符
- 七、匹配非数字
- 八、重复匹配
- 九、正则表达式小总结
- 十、匹配开头和结尾
- 十一、匹配指定范围
- 十二、逻辑或匹配规则
- 十三、使用括号
- 十四、分组匹配
- Pattern
- 十五、非贪婪匹配
- 十六、分割字符串
- 十七、搜索字符串
- 十八、替换字符串
- 十九、反向引用
前言
正则表达式不仅仅是Java的技术,在任何一门编程语言中都会存在,是一种通用的IT技术,其理念和用法在任何编程语言中基本一致,除了有一些由于语言不同而导致的一些语法不同正则表达式,主要用于匹配(查找 替换 计数)字符串中的数据的,也叫做文本匹配技术。
一、正则表达式
经常会需要编写代码来验证用户输人,比如验证输人是否是一个数字,是否是一个全部小写的字符串,或者社会安全号。如何编写这种类型的代码呢?一个简单而有效的做法是使用正则表达式来完成这个任务。
正則表达式(regular expression,简写为 regex) 是一个字符串,用来描述匹配一个字符串集合的模式。对于字符串处理来说,正则表达式是一个强大的工具。可以使用正则表达式来匹配、替换和分割字符串。
比如:给定一个字符串"13088889090",如何判断它是手机号?
public boolean isPhoneNumber(String s) {if (s.length() != 11) {return false;}for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);if (c < '0' || c > '9') {return false;}}return true;
}
对于上述问题的求解而言,我们只解决了长度的问题,内容必须是数字字符的问题,但是,对于手机号这个特殊的数字而言
第1位能否为0?前3位表示对应公司(联通 移动 电信)123 109 110??? 前3位它不是真随机的?就现在这两个问题而言,如果再去用代码做的话,会比较复杂一些;
比如:对于给定给一个字符串s,如何判断该字符串是邮箱地址呢?
public boolean isEmail(String s) {......
}
“zh@xianoupeng.com” “346530074@qq.com” "H_LaK_123@haha.xixi.lala.gov"
为了每一种判断逻辑都要编写代码实现是太繁琐了,正则表达式就是出来解决这些问题的!
如果用正则表达式,去匹配手机号的话
public boolean isPhoneNumber(String s) {//确定了长度为11 并且也确定了必须是数字字符return s.matches("\\d{11}");
}
从目前的角度而言,问题的解决确实变简单了,代码可读性的难度就上来了
在Java标准库中java.uitl.regex包里内置了正则表达式引擎,在Java程序中使用正则非常方便,使用的正则表达式就是一个描述规则的字符串,所以,我们只需要编写正确的规则,我们就可以让正则表达式引擎去判断目标字符串是否符合规则即可。
比如:判断一个年份 "20##"年,我们写出规则如下:
一个4个字符:2,0 ,0~9任意一个数字 ,0~9任意一个数字;
对应的正则表达式:20\d\d
其中\d
表示的是任意一个数字的意思;
但是在Java中,正则表达式要用字符串来表示,"20\d\d"这样写是不对的,因为在Java中 " \ “是转义字符,最终应该这么写"20\\d\\d”。
二、匹配规则
正则表达式的匹配规则是从左到右按规则匹配的。我们首先来看如何用正则表达式进行精确匹配:
对于正则表达式 abc 来说,它只能精确地匹配字符串 “abc” ,不能匹配 “ab” , “Abc” , “abcd” 等其他任何字符串。
如果正则表达式有特殊字符,那就需要用 \ 转义。例如,正则表达式 a\&c ,其中 \& 是用来匹配特殊字符 & 的,它能精确匹配字符串 “a&c” ,但不能匹配 “ac” 、 “a-c” 、 “a&&c” 等。
要注意正则表达式在Java代码中也是一个字符串,所以,对于正则表达式 a\&c 来说,对应的Java字符串是 “a\\&c” ,因为 \ 也是Java字符串的转义字符,两个 \\ 实际上表示的是一个 \ :
String regex01 = "20\\d\\d";System.out.println("2019".matches(regex01));System.out.println("2100".matches(regex01));System.out.println("20AB".matches(regex01));String regex02 = "abc";System.out.println("abc".matches(regex02));System.out.println("ab".matches(regex02));String regex03 = "a\\&c";System.out.println("a&c".matches(regex03));System.out.println("ac".matches(regex03));
如果想匹配非ASCII字符,例如中文,那就用 \u#### 的十六进制表示,例如: a\u548cc 匹配字符串 “a和c” ,中文字符 和 的Unicode编码是 548c 。
String regex04 = "a\\u548cc";System.out.println("a和c".matches(regex04));System.out.println("a哈c".matches(regex04));
三、匹配任意字符
精确匹配实际上用处不大,因为我们直接用 String.equals() 就可以做到。大多数情况下,我们想要的匹配规则更多的是模糊匹配。我们可以用 “ . ”匹配一个任意字符。
例如,正则表达式 a.c 中间的 . 可以匹配一个任意字符,例如,下面的字符串都可以被匹配:
- “abc” ,因为 . 可以匹配字符 b ;
- "a&c" ,因为 . 可以匹配字符 & ;
- “acc” ,因为 . 可以匹配字符 c 。
但它不能匹配 “ac” 、 “a&&c” ,因为 . 匹配一个字符且仅限一个字符。
String regex05 = "a.c";
System.out.println("abc".matches(regex05));//true
System.out.println("a&c".matches(regex05));//true
System.out.println("acc".matches(regex05));//true
System.out.println("ac".matches(regex05));//false
System.out.println("a&&c".matches(regex05));//false
四、匹配数字
用 . 可以匹配任意字符,这个口子开得有点大。如果我们只想匹配 0 ~ 9 这样的数字,可以用 \d 匹配。例如,正则表达式 00\d 可以匹配:
- “007” ,因为 \d 可以匹配字符 7 ;
- “008” ,因为 \d 可以匹配字符 8 。
它不能匹配 “00A” , “0077” ,因为 \d 仅限单个数字字符。
String regex06 = "Demo\\d\\d\\.java";
System.out.println("Demo11.java".matches(regex06));//true
System.out.println("Demo123.java".matches(regex06));//false
System.out.println("Demo.java".matches(regex06));//false
System.out.println("Demo12.avi".matches(regex06));//false
五、匹配常用字符
用 \w 可以匹配一个字母、数字或下划线,w的意思是word。例如, java\w 可以匹配:
- “javac” ,因为 \w 可以匹配英文字符 c ;
- “java9” ,因为 \w 可以匹配数字字符 9 ;
- “java_” ,因为 \w 可以匹配下划线 _ 。
它不能匹配 “java#” , "java " ,因为 \w 不能匹配 # 、空格等字符。
String regex07 = "java\\w";
System.out.println("java_".matches(regex07));//true
System.out.println("javac".matches(regex07));//true
System.out.println("java".matches(regex07));//false
System.out.println("java!".matches(regex07));//false
六、匹配空格字符
用 \s 可以匹配一个空格字符,注意空格字符不但包括空格 " “`,还包括tab字符(在Java中用制表符”\t"表示)。 例如,a\sc可以匹配:
- “a c” ,因为 \s 可以匹配空格字符
" "
; - “a c” ,因为 \s 可以匹配tab字符 \t 。
它不能匹配 “ac” , “abc” 等。
String regex08 = "a\\sc";
System.out.println("a c".matches(regex08));//true
System.out.println("a c".matches(regex08));//false
System.out.println("ac".matches(regex08));//false
System.out.println("a c".matches(regex08));//false
System.out.println("a\tc".matches(regex08));//true
七、匹配非数字
用 \d 可以匹配一个数字,而 \D 则匹配一个非数字。例如, 00\D 可以匹配:
- “00A” ,因为 \D 可以匹配非数字字符 A ;
- “00#” ,因为 \D 可以匹配非数字字符 # 。
00\d 可以匹配的字符串 “007” , “008” 等, 00\D 是不能匹配的。
类似的, \W 可以匹配 \w 不能匹配的字符, \S 可以匹配 \s 不能匹配的字符,这几个正好是反着来的。
所以说:
\d
任意一个数字\D
任意一个非数字;\s
任意一个空格\S
任意一个非空格;\w
任意一个数字字母下划线\W
任意一个非数字字母下划线
String regex09 = "\\d\\w\\W\\D";
System.out.println("1234".matches(regex09));//false
System.out.println("9w!c".matches(regex09));//true
八、重复匹配
我们用 \d 可以匹配一个数字,例如, A\d 可以匹配 “A0” , “A1” ,如果要匹配多个数字,比如 “A380” ,怎么办?
修饰符 * 可以匹配任意个字符,包括0个字符。我们用 A\d* 可以匹配:
- A :因为 \d* 可以匹配0个数字;
- A0 :因为 \d* 可以匹配1个数字 0 ;
- A380 :因为 \d* 可以匹配多个数字 380 。
String regex10 = "A*"; //连续0个或多个A
System.out.println("A".matches(regex10));
System.out.println("Animal".matches(regex10));
System.out.println("A123123".matches(regex10));
System.out.println("AAAAAAA".matches(regex10));
String regex11 = "A\\d*";
System.out.println("A12313123123".matches(regex11));
System.out.println("A".matches(regex11));
System.out.println("Aasdhjahsjdk1123".matches(regex11));
System.out.println("".matches(regex11));
修饰符 + 可以匹配至少一个字符。我们用 A\d+ 可以匹配:
- A0 :因为 \d+ 可以匹配1个数字 0 ;
- A380 :因为 \d+ 可以匹配多个数字 380 。
但它无法匹配 “A” ,因为修饰符 + 要求至少一个字符。
String regex12 = "A\\d+";
System.out.println("A12313123123".matches(regex12));
System.out.println("A".matches(regex12));
System.out.println("Aasdhjahsjdk1123".matches(regex12));
System.out.println("".matches(regex12));
修饰符 ? 可以匹配0个或一个字符。我们用 A\d? 可以匹配:
- A :因为 \d? 可以匹配0个数字;
- A0 :因为 \d+ 可以匹配1个数字 0 。
但它无法匹配 “A33” ,因为修饰符 ? 超过1个字符就不能匹配了。
String regex13 = "A\\d?";
System.out.println("A12313123123".matches(regex13));
System.out.println("A".matches(regex13));
System.out.println("A1".matches(regex13));
System.out.println("".matches(regex13));
如果我们想精确指定n个字符怎么办?用修饰符 {n} 就可以。 A\d{3} 可以精确匹配:
- A380 :因为 \d{3} 可以匹配3个数字 380 。
如果我们想指定匹配n~m个字符怎么办?用修饰符 {n,m} 就可以。 A\d{3,5} 可以精确匹配:
- A380 :因为 \d{3,5} 可以匹配3个数字 380 ;
- A3800 :因为 \d{3,5} 可以匹配4个数字 3800 ;
- A38000 :因为 \d{3,5} 可以匹配5个数字 38000 。
如果没有上限,那么修饰符 {n,} 就可以匹配至少n个字符。
System.out.println("A123".matches("A\\d{3}"));
System.out.println("A123".matches("A\\d{3,5}"));
System.out.println("A12345".matches("A\\d{3,5}"));
System.out.println("A123".matches("A\\d{4,}"));
比如匹配一个座机号 010-33167854 3个数字-8个数字 \d{3}\-\d{8}
。
System.out.println("010-12345678".matches("\\d{3}\\-\\d{8}"));
System.out.println("0101-2345678".matches("\\d{3}\\-\\d{8}"));
九、正则表达式小总结
正则表达式 规则 可以匹配
A 固定字符A "A"
\u548c 指定Unicode字符 "和"
. 任意一个字符 "a" "1" " "
\d 一个数字字符0~9 "0"~"9"
\w 一个数字或字母或下划线
\W 非\w
\D 非\d
\s 一个空格字符(\t ' ')
\S 非\s
A* A有任意个 "" "A" "AA" "AAA"
A+ A至少一个 "A" "AA" "AAA"
A? A0个或1个 "" "A"
A{3} A出现3次 "AAA"
A{3,5} A出现3~5次 "AAA" "AAAA" "AAAAA"
A{2,} A出现至少2次 "AA" "AAA" "AAAA"
A{0,3} A出现0~3次 "" "A" "AA" "AAA"
十、匹配开头和结尾
用正则表达式进行多行匹配时,我们用 ^ 表示开头,$ 表示结尾。例如, ^A\d{3}$ ,可以匹配 “A001” 、 “A380” 。
String regex01 = "^Demo\\w*\\.java$";
System.out.println("Demo01.java".matches(regex01));//true
十一、匹配指定范围
如果我们规定一个7~8位数字的电话号码不能以 0 开头,应该怎么写匹配规则呢? \d{7,8} 是不行的,因为第一个 \d 可以匹配到 0 。
使用 […] 可以匹配范围内的字符,例如, [123456789] 可以匹配 1 ~ 9 ,这样就可以写出上述电话号码的规则: [123456789]\d{6,7} 。
把所有字符全列出来太麻烦, […] 还有一种写法,直接写 [1-9] 就可以。
要匹配大小写不限的十六进制数,比如 1A2b3c ,我们可以这样写: [0-9a-fA-F] ,它表示一共可以匹配以下任意范围的字符:
- 0-9 :字符 0 ~ 9 ;
- a-f :字符 a ~ f ;
- A-F :字符 A ~ F 。
如果要匹配6位十六进制数,前面讲过的 {n} 仍然可以继续配合使用: [0-9a-fA-F]{6} 。
[…] 还有一种排除法,即不包含指定范围的字符。假设我们要匹配任意字符,但不包括数字,可以写 [^1-9]{3} :
- 可以匹配 “ABC” ,因为不包含字符 1 ~ 9 ;
- 可以匹配 “A00” ,因为不包含字符 1 ~ 9 ;
- 不能匹配 “A01” ,因为包含字符 1 ;
- 不能匹配 “A05” ,因为包含字符 5 。
String regex02 = "[2-9]\\d{5}";
System.out.println("345678".matches(regex02));//true
System.out.println("123456".matches(regex02));//falseString regex03 = "[0-9a-fA-F]{4}";
System.out.println("12ab".matches(regex03));//true
System.out.println("wc99".matches(regex03));//false
十二、逻辑或匹配规则
用 | 连接的两个正则规则是或 规则,例如, AB|CD 表示可以匹配 AB 或 CD 。
String regex04 = ".*java|c|python|go.*";
System.out.println("I like java".matches(regex04));//true
System.out.println("I like c++".matches(regex04));//false
十三、使用括号
现在我们想要匹配字符串 learn java 、 learn php 和 learn go 怎么办?一个最简单的规则是 learn\sjava|learn\sphp|learn\sgo ,但是这个规则太复杂了,可以把公共部分提出来,然后用 (…) 把子规则括起来表示成 learn\s(java|php|go) 。
String regex05 = "learn\\s(java|php|go)";
System.out.println("learn java".matches(regex05));//true
System.out.println("learn c++".matches(regex05));//false
复杂匹配规则主要有:
十四、分组匹配
我们前面讲到的 (…) 可以用来把一个子规则括起来,这样写 learn\s(java|php|go) 就可以更方便地匹配长字符串了。
实际上 (…) 还有一个重要作用,就是分组匹配。
我们来看一下如何用正则匹配 区号-电话号
码这个规则。利用前面讲到的匹配规则,写出来很容易:
\d{3,4}-\d{6,8}
虽然这个正则匹配规则很简单,但是往往匹配成功后,下一步是提取区号和电话号码,分别存入数据库。于是问题来了:如何提取匹配的子串?
当然可以用 String 提供的 indexOf() 和 substring() 这些方法,但它们从正则匹配的字符串中提取子串没有通用性,下一次要提取 learn\s(java|php) 还得改代码。
正确的方法是用 (…) 先把要提取的规则分组,把上述正则表达式变为 (\d{3,4})- (\d{6,8}) 。
现在问题又来了:匹配后,如何按括号提取子串?
现在我们没办法用 String.matches() 这样简单的判断方法了,必须引入 java.util.regex 包,底层实际上先创建一个关于正则表达式规则的对象Pattern, 然后规则对象Pattern对数据进行匹配,生成一个匹配对象Matcher,匹配的结果:都在Matcher里,有一个方法Matcher中的**mathces()**才是最终判断字符串是否匹配规则的结果boolean,如果匹配成功,就可以直接从 Matcher.group(index) 返回子串:
Pattern p = Pattern.compile("(\\d{3,4})-(\\d{6,8})");
Matcher m = p.matcher("010-12345678");
if (m.matches()) {//获取的结果是整个电话号System.out.println(m.group(0));//获取的第一个部分 区号System.out.println(m.group(1));//获取的第二个部分 电话System.out.println(m.group(2));
}
Pattern
我们在前面的代码中用到的正则表达式代码是 String.matches()
方法,而我们在分组提取的代码中用的是 java.util.regex
包里面的 Pattern
类和 Matcher
类。实际上这两种代码本质上是一样的,因为 String.matches()
方法内部调用的就是 Pattern
和 Matcher
类的方法。
但是反复使用 String.matches()
对同一个正则表达式进行多次匹配效率较低,因为每次都会创建出一样的 Pattern
对象。完全可以先创建出一个 Pattern
对象,然后反复使用,就可以实现编译一次,多次匹配:
public class Main { public static void main(String[] args) { Pattern pattern = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})"); pattern.matcher("010-12345678").matches(); // true pattern.matcher("021-123456").matches(); // true pattern.matcher("022#1234567").matches(); // false // 获得Matcher对象: Matcher matcher = pattern.matcher("010-12345678"); if (matcher.matches()) { String whole = matcher.group(0); // "010-12345678", 0表示匹配的整个字符串 String area = matcher.group(1); // "010", 1表示匹配的第1个子串 String tel = matcher.group(2); // "12345678", 2表示匹配的第2个子串 System.out.println(area); System.out.println(tel); }}
}
使用Matcher时,必须首先调用matches()判断是否匹配成功,匹配成功后,才能调用group()提取子串。
利用提取子串的功能,我们轻松获得了区号和号码两部分。
正则表达式用
(...)
分组可以通过Matcher
对象快速提取子串:
group(0)
表示匹配的整个字符串;group(1)
表示第1个子串;group(2)
表示第2个子串,以此类推。
十五、非贪婪匹配
在介绍非贪婪匹配前,我们先看一个简单的问题:
给定一个字符串表示的数字,判断该数字末尾 0 的个数。例如:
"123000"
:3个0
"10100"
:2个0
"1001"
:0个0
可以很容易地写出该正则表达式:(\d+)(0*)
,Java代码如下:
Pattern p1 = Pattern.compile("(\\d+)(0*)");
Matcher m1 = p1.matcher("123000");
if (m1.matches()) {System.out.println("group1 = " + m1.group(1));System.out.println("group2 = " + m1.group(2));
}
然而打印的第二个子串是空字符串" "
。
实际上,我们期望分组匹配结果是:
但实际的分组匹配结果是这样的:
仔细观察上述实际匹配结果,实际上它是完全合理的,因为 \d+
确实可以匹配后面任意个 0
。
这是因为正则表达式默认使用贪婪匹配:任何一个规则,它总是尽可能多地向后匹配,因此,\d+
总是会把后面的 0
包含进来。
要让 \d+
尽量少匹配,让 0*
尽量多匹配,我们就必须让 \d+
使用非贪婪匹配。在规则 \d+
后面加个 ?
即可表示非贪婪匹配。 我们改写正则表达式如下:
Pattern p1 = Pattern.compile("(\\d+?)(0*)");
Matcher m1 = p1.matcher("123000");
if (m1.matches()) {System.out.println("group1 = " + m1.group(1));System.out.println("group2 = " + m1.group(2));
}
结果:
因此,给定一个匹配规则,加上 ?
后就变成了非贪婪匹配。
我们再来看这个正则表达式 (\d??)(9*)
,注意 \d?
表示匹配0
个或1
个数字,后面第二个 ?
表示非贪婪匹配,因此,给定字符串"9999"
,匹配到的两个子串分别是""
和 "9999"
, 因为对于\d?
来说,可以匹配1个9
,也可以匹配0个 9
,但是因为后面的 ?
表示非贪婪匹配,它就会尽可能少的匹配,结果是匹配了0个 9
。
十六、分割字符串
使用正则表达式分割字符串可以实现更加灵活的功能。 String.split()
方法传入的正是正则表达式。我们来看下面的代码:
System.out.println(Arrays.toString("a b c".split("\\s")));
System.out.println(Arrays.toString("a b c".split("\\s")));
System.out.println(Arrays.toString("a b c".split("\\s+")));
System.out.println(Arrays.toString("a , b ;; c ,,;; d , e".split("[\\,\\;\\s]+")));
结果:
如果我们想让用户输入一组标签,然后把标签提取出来,因为用户的输入往往是不规范的,这时,使用合适的正则表达式,就可以消除多个空格、混合 ,
和 ;
这些不规范的输入,直接提取出规范的字符串。
十七、搜索字符串
使用正则表达式还可以搜索字符串,我们来看例子:
String s = "the quick brown fox jumps over the lazy dog";
Pattern p2 = Pattern.compile("\\wo\\w");
Matcher m2 = p2.matcher(s);
while (m2.find()) {//Matcher的start和end是从左到右每一个匹配到的字符串在原字符串中的起始位置String sub = s.substring(m2.start(),m2.end());System.out.println(sub);
}
结果:
我们获取到 Matcher
对象后,不需要调用 matches()
方法(因为匹配整个串肯定返回false),而是反复调用 find()
方法,在整个串中搜索能匹配上\\wo\\w
规则的子串,并打印出来。这种方式比 String.indexOf()
要灵活得多,因为我们搜索的规则是3个字符:中间必须是o
,前后两个必须是字符 [A-Za-z0-9_]
。
十八、替换字符串
使用正则表达式替换字符串可以直接调用 String.replaceAll()
,它的第一个参数是正则表达式,第二个参数是待替换的字符串。我们还是来看例子:
String s1 = "The quick\t\t brown fox jumps over the lazy dog.";
s1 = s1.replaceAll("\\s+", " ");
System.out.println(s1); // "The quick brown fox jumps over the lazy dog."
上面的代码把不规范的连续空格分隔的句子变成了规范的句子。可见,灵活使用正则表达式可以大大降低代码量。
十九、反向引用
如果我们要把搜索到的指定字符串按规则替换,比如前后各加一个 xxxx
,这个时候,使用replaceAll()
的时候,我们传入的第二个参数可以使用 $1
、$2
来反向引用匹配到的子串。例如:
String s1 = "the quick brown fox jumps over the lazy dog";
s1 = s1.replaceAll("\\s([a-z]{4})\\s","<h1>$1</h1>");//<h1>lazy</h1>
System.out.println(s1);String s2 = "010-123456 0101-33445566 010-98712345";
//"010-123456" => "(010)-[123456]"
s2 = s2.replaceAll("(\\d{3,4})-(\\d{6,8})","($1)-[$2]");
System.out.println(s2);
结果:
它实际上把任何4字符单词的前后用xxxx
括起来。实现替换的关键就在于 " $1 "
,它用匹配的分组子串 ([a-z]{4})
替换了$1
。
Java中的正则表达式 regex相关推荐
- Java中的正则表达式 - Java Regex示例
Java中的正则表达式 - Java Regex示例 欢迎使用Java中的正则表达式.它在Java中也称为Regex.当我开始编程时,java正则表达式对我来说是一场噩梦.本教程旨在帮助您掌握Java ...
- java 中的正则表达式_Java中的正则表达式–软介绍
java 中的正则表达式 正则表达式是一种可以应用于文本(Java中的String)的模式. Java提供了java.util.regex包,用于与正则表达式进行模式匹配. Java正则表达式与Per ...
- java正则表达式性能_译:Java 中的正则表达式性能概述
译者:Darren Luo 1. 概述 在本快速教程中,我们将展示模式匹配引擎是如何工作的.我们还将介绍在 Java 中优化正则表达式的不同方式. 有关正则表达式的的使用介绍,请参阅此文. 2. 模式 ...
- 详解Java中的正则表达式
详解Java中的正则表达式,并列出常用的正则表达式语法和一些常用的场景. 判断一个字符串是否是由数字组成: 当不使用正则表达式的时候的实现代码: public class RegexDemo01 {p ...
- java中,正则表达式的使用 (最普通使用,Group,贪婪模式)
目录 0.最普通的使用 1.正则表达式有Group功能. 2.正则表达式中的贪婪模式, 非贪婪模式(*?) 3.find() 与 matches() 之间的区别 ↓循环获取所有文件 ↓文件内部内容读取 ...
- java中的正则表达式类---表情转换实例
Java中的正则表达式类 ________________________________________ public interface MatchResult 匹配操作的结果. 此接口包含用于确 ...
- 【JavaSE】java中的正则表达式(从0到1学会正则表达式)
文章目录 前言 一.正则表达式的三个常用类 1.Pattern类 2.Matcher类 3.PatternSyntaxException类 二.正则表达式的底层实现 1.Matcher.find()和 ...
- java js 正则表达式_如何在JavaScript与Java中使用正则表达式
如何在JavaScript与Java中使用正则表达式 发布时间:2021-02-11 13:16:01 来源:亿速云 阅读:69 作者:Leah 如何在JavaScript与Java中使用正则表达式? ...
- java 正则表达式 判断 日期_怎么在java中利用正则表达式对时间日期进行判断
怎么在java中利用正则表达式对时间日期进行判断 发布时间:2020-12-08 16:18:34 来源:亿速云 阅读:105 作者:Leah 这篇文章给大家介绍怎么在java中利用正则表达式对时间日 ...
最新文章
- Windows 2008 ×××与 CA
- jquery实现tab切换加自动滚动切换
- 第十天:估算活动持续时间,类比估算,参数估算,自下而上估算,三点估算解析表
- HUB,交换机,路由器,MODEM都有什么区别???
- c语言void结尾,c语言中的void和void*
- 素数筛 python
- win10电源设置选项无效--高级电源选项
- 最简单的人脸识别系统搭建
- leaflet所有示例下载
- 计算机组成原理——加减运算 溢出判断
- mybatis sql 改写
- 微信小程序超级占内存_实测:微信小程序究竟会占用多少内存?结果竟然
- 微信小程序跳过第三方的_微信小程序怎么解除第三方授权?
- ASM 1——概念简介
- 【Android】更换头像的实现
- 汉语言处理工具pyhanlp的拼音转换与字符正则化 1
- 视频处理中的VBI是什么?
- [C++]已知f(x) = cosx - x。x的初值为3.14159/4,用牛顿法求解方程f(x) = 0的近似解,要求精确到10-6。f(x)的牛顿法的表达式为xn+1 = xn + (cosxn
- generator详解
- Kettle javaScript脚本的使用
热门文章
- edge打开pdf不显示印章_win10 Edge浏览器打不开pdf文件的解决方法
- android恢复出厂设置流程
- 031:verbatim 标签
- iOS 查看Realm数据库表
- 如何将谷歌卫星地图转成80坐标并测量面积
- oracle检查表的级联关系,有条件的两个表关联查询为什么会出现 MERGE JOIN CARTESIAN操作...
- 用matlab求摆线,求由摆线x=a(t-sint),y=a(1-cost)的一拱(0≦t≦2π)与x轴所围成的图形面积...
- 博客第二课-静态主页
- python程序实例下载_Python经典实例
- 请教dalao,为什么运行时二三步会合并到一起?