JAVA中正则表达式学习总结
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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
true
true
true
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()); } } }
运行结果:
is
is
有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中正则表达式学习总结的主要内容,如果未能解决你的问题,请参考以下文章