JAVA中正则表达式学习总结

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、JAVA中正则表达式相关的类

1. java.util.regex.Pattern

该类用于编译模式，模式可以理解为一个正则表达式，比如：a*b。

用法如下：

// 创建模式

Pattern p = Pattern.compile("a*b");

// 创建该模式的匹配器

Matcher m = p.matcher("aaaaab");

2. java.util.regex.Matcher

该类用于创建匹配器和进行匹配操作。

用法如下：

// 进行匹配操作

boolean b = m.matches();

3. 运行一个正则表达式入门案例

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("a*b");
// 创建该模式的匹配器
Matcher m = p.matcher("aaaaab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

二、正则表达式基础

1. 纯文本也是一个正则表达式

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("ab");
// 创建该模式的匹配器
Matcher m = p.matcher("ab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true;

2. 字符可以匹配任意单个的字符、字母、数字。

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile(".b");
// 创建该模式的匹配器
Matcher m = p.matcher("ab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

3. 用[ ]匹配一组字符

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[0123456789]");
// 创建该模式的匹配器，5和[0123456789]中的某一个匹配
Matcher m = p.matcher("5");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

4. 用-简化[ ]中元素的列举

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[0-9]");
// 创建该模式的匹配器
Matcher m = p.matcher("5");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

类似用法：[a-z]、[A-Z]、[a-zA-Z]、[a-zA-Z0-9]

注意：类似[z-a]的是非法的regex。

-只有在[ ]中才是元字符，如果在[ ]就是一个普通字符。

5. ^取非操作符

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[^0-9a]");
// 创建该模式的匹配器,注意^取非是集合[]中所有元素取非，不只是0-9
Matcher m = p.matcher("a");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：false

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[^0-9]");
// 创建该模式的匹配器
Matcher m = p.matcher("a");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

6. 匹配数字的元字符：\d 等价于[0-9]

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式,注意在正则表达式中\也需要转义即：\\
Pattern p = Pattern.compile("\\d");
// 创建该模式的匹配器
Matcher m = p.matcher("4");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

7. 匹配非数字的元字符：\D相当于[^0-9]

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\D");
// 创建该模式的匹配器
Matcher m = p.matcher("4");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：false

8. \w：匹配任何一个字母数字字符（大小写均可）或下划线字符（等价于[a-zA-Z0-9_]）

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\w");
// 创建该模式的匹配器
Matcher m = p.matcher("_");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

9. 匹配任何一个非字母数字或非下划线字符（等价于[^a-zA-Z0-9_]）

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\W");
// 创建该模式的匹配器
Matcher m = p.matcher("_");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

10. +匹配一个或多个（至少一个）。+遇到[ ]一般放在[ ]后，如果放在[ ]中就只是一个元素

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 +可以重复一个集合[]也可以是一个字符
Pattern p = Pattern.compile("[abc]+");
// 创建该模式的匹配器
Matcher m = p.matcher("aaccbbabc");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d+");
// 创建该模式的匹配器
Matcher m = p.matcher("1114578");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

11. *匹配零个或多个

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d*");
// 创建该模式的匹配器
Matcher m = p.matcher("");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

12. ？匹配零个或一个（最多一个）

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d?");
// 创建该模式的匹配器
Matcher m = p.matcher("");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d?");
// 创建该模式的匹配器
Matcher m = p.matcher("2");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d?");
// 创建该模式的匹配器
Matcher m = p.matcher("25");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：false

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[abc]?");
// 创建该模式的匹配器
Matcher m = p.matcher("c");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

13. { }指定重复匹配的次数

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 {2}表示匹配两次
Pattern p = Pattern.compile("[abc]{2}");
// 创建该模式的匹配器
Matcher m = p.matcher("cc");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 {2,5}最少匹配2次，最多匹配5次
Pattern p = Pattern.compile("[abc]{2,5}");
// 创建该模式的匹配器
Matcher m = p.matcher("ccab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式最好重复匹配3次
Pattern p = Pattern.compile("[abc]{3,}");
// 创建该模式的匹配器
Matcher m = p.matcher("ccabbbbbbbbbbbbbb");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}

运行结果：true

14. ( )中的|表示“或”

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("t(a|e|i|o|oo)n");
// 输出匹配结果
System.out.println(p.matcher("tan").matches());
System.out.println(p.matcher("ten").matches());
System.out.println(p.matcher("tin").matches());
System.out.println(p.matcher("ton").matches());
//[ ]中只能匹配一个字符，而( )中可以不止一个字符，如“oo”
System.out.println(p.matcher("toon").matches());
}
}

运行结果：

true

当一个模式使用多次时,以下写法会编译多次,会影响性能.

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
//如果要多次使用一种模式，编译一次后重用此模式比每次都调用此方法效率更高。
System.out.println(Pattern.matches("t(a|e|i|o|oo)n", "toon"));
}
}
运行结果：true

15. \b指定单词边界,匹配的长度可以认为为“0”。b是英文boundary(边界)的首字母。

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\bis\\b");
// 创建该模式的匹配器
Matcher m = p.matcher("This is a dog,that is a cat");
// 进行匹配操作
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

有4种位置被认为是“单词边界”：

1)在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)

2)在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)

3)在一个“单词字符”和“非单词字符”之间，其中“非单词字符”紧跟在“单词字符”之后

4)在一个“非单词字符”和“单词字符”之间，其中“单词字符”紧跟在“非单词字符”后面“单词字符”是可以用“\w”匹配的字符，“非单词字符”是可以用“\W”匹配的字符。

正则表达式匹配单词的原理探讨：

让我们看看把正则表达式<<\bis\b>>应用到字符串“This island is beautiful”。引擎先处理符号<<\b>>。因为\b是0长度，所以第一个字符T前面的位置会被考察。

因为T是一个“单词字符”，而它前面的字符是一个空字符(void)，所以\b匹配了单词边界。接着<<i>>和第一个字符“T”匹配失败。

匹配过程继续进行，直到第五个空格符，和第四个字符“s”之间又匹配了<<\b>>。然而空格符和<<i>>不匹配。

继续向后，到了第六个字符“i”，和第五个空格字符之间匹配了<<\b>>，然后<<is>>和第六、第七个字符都匹配了。

然而第八个字符和第二个“单词边界”不匹配，所以匹配又失败了。到了第13个字符i，因为和前面一个空格符形成“单词边界”，同时<<is>>和“is”匹配。

引擎接着尝试匹配第二个<<\b>>。因为第15个空格符和“s”形成单词边界，所以匹配成功。引擎“急着”返回成功匹配的结果。

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 ,匹配以th或Th开头的单词（注意：模式默认是区分大小写的）
Pattern p = Pattern.compile("(\\bth\\w+|\\bTh\\w+)");
// 创建该模式的匹配器
Matcher m = p.matcher("This is a dog,that is a cat");
// 进行匹配操作
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

This

that

16. 字符串边界

用来定义字符串边界的元字符有两个：一个是用来定义字符串开头的^,另一个是用来定义字符串结尾的$。

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式匹配一个字符串
Pattern p = Pattern.compile("^this\\s+a\\s+dog$");
// 创建该模式的匹配器
Matcher m = p.matcher("this a dog");
// 进行匹配操作，并输出匹配结果
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

this a dog

17. 注意：重复匹配的元字符（*，？，｛3｝，+）只作用于紧挨着她的的前一个字符或元字符或字表达式。

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("https?");
// 创建该模式的匹配器
Matcher m = p.matcher("http");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

http

18. ()子表达式。子表达式用()包裹起来，可以理解为包含其他元字符的一个元字符。

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}");
// 创建该模式的匹配器
Matcher m = p.matcher("Pinging baidu.com [12.159.46.200] with 32 bytes of data");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

12.159.46.200

ublic class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式，匹配ip。把上面重复的\\d{1,3}\\.可以认为是一个字表达式
Pattern p = Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}");
// 创建该模式的匹配器
Matcher m = p.matcher("Pinging baidu.com [12.159.46.200] with 32 bytes of data;");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

12.159.46.200

19. 子表达式的嵌套

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式,匹配19或20开头的年份
Pattern p = Pattern.compile("(19|20)\\d{2}");
// 创建该模式的匹配器
Matcher m = p.matcher("today is 2014-4-7");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

2014

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式,匹配一个合法IP(最大只能是255)
Pattern p = Pattern.compile("((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])\\.){3}((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))");
// 创建该模式的匹配器
Matcher m = p.matcher("IP: 265.255.10.0");
System.out.println(m.matches());
}
}

运行结果：

false

三、常用实例

1. 只匹配中文

public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
// 创建该模式的匹配器
Matcher m = p.matcher("china中国");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}

运行结果：

中

国

正文

一、JAVA中正则表达式相关的类

1. java.util.regex.Pattern

2. java.util.regex.Matcher

3. 运行一个正则表达式入门案例

二、正则表达式基础

1. 纯文本也是一个正则表达式

2. 字符可以匹配任意单个的字符、字母、数字。

3. 用[ ]匹配一组字符

4. 用-简化[ ]中元素的列举

5. ^取非操作符

6. 匹配数字的元字符：\d 等价于[0-9]

7. 匹配非数字的元字符：\D相当于[^0-9]

8. \w：匹配任何一个字母数字字符（大小写均可）或下划线字符（等价于[a-zA-Z0-9_]）

9. 匹配任何一个非字母数字或非下划线字符（等价于[^a-zA-Z0-9_]）

10. +匹配一个或多个（至少一个）。+遇到[ ]一般放在[ ]后，如果放在[ ]中就只是一个元素

11. *匹配零个或多个

12. ？匹配零个或一个（最多一个）

13. { }指定重复匹配的次数

14. ( )中的|表示“或”

15. \b指定单词边界,匹配的长度可以认为为“0”。b是英文boundary(边界)的首字母。

16. 字符串边界

17. 注意：重复匹配的元字符（*，？，｛3｝，+）只作用于紧挨着她的的前一个字符或元字符或字表达式。

18. ()子表达式。子表达式用()包裹起来，可以理解为包含其他元字符的一个元字符。

19. 子表达式的嵌套

三、常用实例

1. 只匹配中文

相关阅读

关于go深度学习框架交流的信息

go语言爬虫基础学习，go语言实战

学习delphi需要什么c语言，delphi入门与提高实用教程

软件开发需要学习c语言，软件开发与编程需要什么学历

如何快速的学习基本js技术，js怎么学最快

macos学习app，mac os使用教学

小白在哪里学习c语言，小白自学c语言

学习c语言表情包，c语言表情

目录[+]

一、JAVA中正则表达式相关的类

1. java.util.regex.Pattern

2. java.util.regex.Matcher

3. 运行一个正则表达式入门案例

二、正则表达式基础

1. 纯文本也是一个正则表达式

2. 字符可以匹配任意单个的字符、字母、数字。

3. 用[ ]匹配一组字符

4. 用-简化[ ]中元素的列举

5. ^取非操作符

6. 匹配数字的元字符：\d 等价于[0-9]

7. 匹配非数字的元字符：\D相当于[^0-9]

8. \w：匹配任何一个字母数字字符（大小写均可）或下划线字符（等价于[a-zA-Z0-9_]）

9. 匹配任何一个非字母数字或非下划线字符（等价于[^a-zA-Z0-9_]）

10. +匹配一个或多个（至少一个）。+遇到[ ]一般放在[ ]后，如果放在[ ]中就只是一个元素

11. *匹配零个或多个

12. ？匹配零个或一个（最多一个）

13. { }指定重复匹配的次数

14. ( )中的|表示“或”

15. \b指定单词边界,匹配的长度可以认为为“0”。b是英文boundary(边界)的首字母。

16. 字符串边界

17. 注意：重复匹配的元字符（*，？，｛3｝，+）只作用于紧挨着她的的前一个字符或元字符或字表达式。

18. ()子表达式。子表达式用()包裹起来，可以理解为包含其他元字符的一个元字符。

19. 子表达式的嵌套

三、常用实例

1. 只匹配中文

相关阅读

关于go深度学习框架交流的信息

go语言爬虫基础学习，go语言实战

学习delphi需要什么c语言，delphi入门与提高实用教程

软件开发需要学习c语言，软件开发与编程需要什么学历

如何快速的学习基本js技术，js怎么学最快

macos学习app，mac os使用教学

小白在哪里学习c语言，小白自学c语言

学习c语言表情包，c语言 表情

目录[+]

学习c语言表情包，c语言表情