常用正则表达式

一、正则表达式语法

1.元字符

• 字符匹配符
  
• 选择匹配符
  
• 限定符
  
• 定位符
  
• 分组组合和反向引用符
  

元字符(Metacjaracter)-转义号\\
\\符号        说明:在我们使用正则表达式去检索某些特殊字符的时候，需要用到转义符号，否则检索不到结果，甚至会报错。
特殊：在Java的正则表达式中，两个\\代表其他语言中的一个\

需要用到转义符号的字符有.、*、+、(、)、&、/、\、?、[、]、^、{、}

案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp01 {
10.     public static void main(String[] args) {
11.         String content = "a(.dd$.(%^(";
12.         //匹配所有字符
13. //        String regStr = ".";
14.         //匹配点
15. //        String regStr = "\\.";
16.         //匹配括号
17.         String regStr = "\\(";
18.         Pattern pattern = Pattern.compile(regStr);
19.         Matcher matcher = pattern.matcher(content);
21.         while (matcher.find()){
22.             System.out.println("找到" + matcher.group(0));
23.         }
24.     }
25. }

复制代码

运行结果：

1. 找到(
2. 找到(
3. 找到(

复制代码

1.1字符匹配符

符号符号含义示例解释结果[]可接收的字符列表[efgh]e、f、g、h中的任意1个字符e、h[^]不接收的字符列表[^abc]除a、b、c之外的任意1个字符d、h-连字符a-z任意单个小写字母a、b.匹配除\n以外的任意字符，如果只想匹配.则需要用\\.a..b以a开头，b结尾，中间包括2个任意字符的长度为4的字符串addb、a#*b\\d匹配单个数字字符，相当于[0-9]\\d{3}(\\d)?包含3个或4个数字的字符串123、7536\\D匹配单个非数字字符，相当于[^0-9]\\D(\\d)*以单个非数字字符开头，后接任意个数字字符串a、R75\\w匹配单个数字、大小写字母字符、下划线，相当于[0-9、a-z、A-Z、_]\\d{3}\\w{4}以3个数字字符开头的长度为7的数字字母字符串456adFG、753Tfhd\\W匹配单个非数字、大小写字母字符，相当于[^0-9、a-z、A-Z、_]\\W+\\d{2}以至少1个非数字字母字符开头，2个数字字符结尾的字符串+代表1个或多个#52、$%^52\\s匹配空白字符\\S匹配非空白字符案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp02 {
10.     public static void main(String[] args) {
11.         String content = "ad44w8\n5.B6b5d";
12.         //小写a-z
13. //        String regStr = "[a-z]";
14.         //大写A-Z
15. //        String regStr = "[A-Z]";
16.         //[^a-z]{2} 不在a-z之间的连续两个字符
17. //        String regStr = "[^a-z]{2}";
18.         //全部都匹配
19.         String regStr = ".";
20.         //方法一：(?i)不区分大小写
21. //        String regStr = "(?i)wb";
23.         Pattern pattern = Pattern.compile(regStr);
25.         //方法二：这种方法也可以不区分大小写
26. //        Pattern pattern = Pattern.compile(regStr,Pattern.CASE_INSENSITIVE);
27.         Matcher matcher = pattern.matcher(content);
29.         while(matcher.find()){
30.             System.out.println("找到:" + matcher.group(0));
31.         }
32.     }
33. }

复制代码

[^a-z]{2} 不在a-z之间的连续两个字符结果

1. 找到:44
2. 找到:8
4. 找到:5.
5. 找到:B6
7. 8后面那个是\n被换行了

复制代码

1.2选择匹配符

在匹配某个字符串的时候是选择性的。即:既可以匹配这个，又可以匹配那个，这时需要用到选择匹配符号|

符号符号含义示例解释``匹配``之前或之后的表达式案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp03 {
10.     public static void main(String[] args) {
11.         String content = "盖被子 dd 暖和阿斯顿aa想睡";
12.         String regStr = "被子|暖和|睡";
13.         Pattern pattern = Pattern.compile(regStr);
14.         Matcher matcher = pattern.matcher(content);
16.         while(matcher.find()){
17.             System.out.println("找到:" + matcher.group(0));
18.         }
21.     }
22. }

复制代码

运行结果：

1. 找到:被子
2. 找到:暖和
3. 找到:睡

复制代码

1.3限定符

用于指定其前面的字符和组合项连续出现多少次

符号符号含义示例解释结果*指定符号重复0次或n次（无要求）(abc)*仅包含任意abc的字符串abc、abcabc+指定字符重复1次或n次（至少一次）m+(abc)*以至少1个m开头，后接任意个abc的字符串m、mabc、mabcabc、mmabc?指定字符重复0次或1次（最多1次）m+abc?以至少1个m开头，后接ab或abc的字符串,?接最近的mab、mabc、mmab{n}只能输入n个字符[abc]以abc中字母组成的任意长度为3的字符串abc、dbc、adc{n,}指定至少n个匹配[abcd]由abcd中字母组成的任意长度不小于3的字符串abc、ddddd{n,m}指定至少n个但不多于m个匹配[abcd]由abcd中字母组成的任意长度不小于3，并且不大于5的字符串abc、abcd、aaaaa案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp04 {
10.     public static void main(String[] args) {
11.         String content = "asdmmabffm111111amabmabc";
12. //        String regStr = "m+abc?";
13.         //Java默认贪婪匹配,尽可能匹配多的
14.         String regStr = "1{4,5}";
15.         //结果只有5个1
16.         Pattern pattern = Pattern.compile(regStr);
17.         Matcher matcher = pattern.matcher(content);
19.         while(matcher.find()){
20.             System.out.println("找到:" + matcher.group(0));
21.         }
22.     }
23. }

复制代码

1.4定位符

规定要匹配的字符串出现的位置,比如在字符串的开始还是在结束的位置

符号符号含义示例解释结果^指定起始字符^[0-9]+[a-z]*以至少1个数字开头，后接任意个小写字母的字符串2、56f`符号符号含义示例解释--------------------------------------------------------------------------------------------------------------------------------------^指定起始字符^[0-9]+[a-z]*以至少1个数字开头，后接任意个小写字母的字符串2、56f| 指定结束字符           | ^[0-9]\\-[a-z]+$以1个数字开头后接连字符-，并以至少1个小写字母结尾的字符串1-a、2-dd\\b匹配目标字符串的边界qy\\b这里的边界是指离空格最近的和离结束位置最近的qydsjdqy   qyfffqy\\B匹配目标字符串的非边界qy\\b与\\b相反，指开头第一次出现qydsjdqy   qyfffqy案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp05 {
10.     public static void main(String[] args) {
11.         String content = "asdmmabffm111111a1";
12.         //定位符只能找到一个返回
13.         String regStr = "^[a-z]+[0-9]";
14.         Pattern pattern = Pattern.compile(regStr);
15.         Matcher matcher = pattern.matcher(content);
17.         while(matcher.find()){
18.             System.out.println("找到:" + matcher.group(0));
19.         }
20.     }
21. }
23. //运行结果        找到:asdmmabffm1

复制代码

1.5分组

1.5.1常用分组

常用分组构造形式解释(pattern)非命名捕获。捕获匹配的子字符串。编号为零的第一个捕获是由整个正则表达式模式匹配的文本，其它捕获结果则根据左括号的顺序从1开始自动编号。(?patter)命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中。用于name的字符串不能包含任何标点符号，并且不能以数字开头。可以使用单引号替代尖括号，例如(?'name')但是我尝试不能使用非命名分组：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp06 {
10.     public static void main(String[] args) {
11.         String content = "qyxuexi dda5524 dadaqy";
12.         String regStr = "(\\d\\d)(\\d\\d)";
14.         Pattern pattern = Pattern.compile(regStr);
15.         Matcher matcher = pattern.matcher(content);
17.         while(matcher.find()){
18.             System.out.println("找到=" + matcher.group(0));//5524
19.             System.out.println("找到=" + matcher.group(1));//55
20.             System.out.println("找到=" + matcher.group(2));//24
21.         }
22.     }
23. }

复制代码

命名分组：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp06 {
10.     public static void main(String[] args) {
11.         String content = "qyxuexi dda5524 dadaqy";
12.         String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";
14.         Pattern pattern = Pattern.compile(regStr);
15.         Matcher matcher = pattern.matcher(content);
17.         while(matcher.find()){
18.             System.out.println("找到=" + matcher.group(0));//5524
19.             System.out.println("找到=" + matcher.group("g1"));//55
20.             System.out.println("找到=" + matcher.group("g2"));//24
21.         }
22.     }
23. }

复制代码

1.5.2特别分组

特别分组构造形式解释(?:patter)匹配pattern但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符`(?=pattern)它是一个非捕获匹配。例如，`Windows (?=95(?!pattern)该表达式匹配不处于匹配pattern的字符串的起始点的搜索字符串。它是一个非捕获匹配。例如，`Windows (?!95案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp07 {
10.     public static void main(String[] args) {
12.         //说明非捕获的不能用group(1)去获取
14.         String content = "hh阿典yyds 66阿典nb 99阿典xnlxixi";
16.         //第一部分(?:patter)
17. //        String regStr = "阿典yyds|阿典nb|阿典xnl";
18.         //等价于非捕获分组
19. //        String regStr = "阿典(?:yyds|nb|xnl)";
22.         //第二部分(?=pattern)
23.         //只找到阿典yyds与阿典nb中的阿典
24. //        String regStr = "阿典(?=yyds|nb)";
27.         //第三部分(?!=pattern)
28.         //只找到不是阿典yyds与阿典nb中的阿典
29.         String regStr = "阿典(?!yyds|nb)";
31.         Pattern pattern = Pattern.compile(regStr);
32.         Matcher matcher = pattern.matcher(content);
34.         while(matcher.find()){
35.             System.out.println("找到:" + matcher.group(0));
36.         }
37.     }
38. }

复制代码

2.非贪婪匹配

Java正则表达式默认的是贪婪匹配，如果想要进行非贪婪匹配就在需要的地方加一个?
案例：

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp01 {
10.     public static void main(String[] args) {
11.         String content = "456m";
12. //        String regStr = "\\d+";//贪婪匹配 456
13.         String regStr = "\\d+?";//非贪婪匹配 一个一个输出
14.         Pattern pattern = Pattern.compile(regStr);
15.         Matcher matcher = pattern.matcher(content);
17.         while (matcher.find()){
18.             System.out.println("找到" + matcher.group(0));
19.         }
20.     }
21. }

复制代码

二、正则表达式三个常用类

java.util.regex包主要包括以下三个类Pattern类、Matcher类和PatternSyntaxException

1.Pattern类

pattern对象是一个正则表达式对象。Pattern 类没有公共构造方法。要创建一个 Pattern对象，调用其公共静态方法，它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数,比如atternr=Pattern.compile(pattern);

1. //整体匹配，就是全匹配上
2. package com.qy.regexp;
4. import java.util.regex.Matcher;
5. import java.util.regex.Pattern;
7. /**
8. * @auther QY
9. */
10. public class RegExp10 {
11.     public static void main(String[] args) {
12.         String content = "https://space.bilibili.com/327811521?spm_id_from=333.1007.0.0";
13.         //这里去掉了左右的定位符
14.         String regStr = "((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.]*)?";
16.         System.out.println(Pattern.matches(regStr,content));
18.     }
19. }

复制代码

2.Matcher 类

Matcher对象是对输入字符串进行解释和匹配的引擎。与Pattern类一样,Matcher也没有公共构造方法。你需要调用 Pattern对象的matcher 方法来获得一个Matcher对象

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp11 {
10.     public static void main(String[] args) {
11.         String content = "hello ddd hello dsa$ hello";
12.         String regStr = "hello.*";
14.         Pattern pattern = Pattern.compile(regStr);
15.         Matcher matcher = pattern.matcher(content);
17.         while(matcher.find()){
18.             System.out.println("================");
19.             System.out.println(matcher.start());
20.             System.out.println(matcher.end());
21.             System.out.println("找到:" + content.substring(matcher.start(),matcher.end()));
22.             System.out.println("整体匹配:"+matcher.matches());
23.         }
25.         //matcher.replaceAll()用于替换
26.         regStr = "hello";
27.         pattern = Pattern.compile(regStr);
28.         matcher = pattern.matcher(content);
29.         //原来的文本并不会替换
30.         /**
31.          * 结果
32.          * 你好 ddd 你好 dsa$ 你好
33.          * hello ddd hello dsa$ hello
34.          */
35.         String newContent = matcher.replaceAll("你好");
36.         System.out.println(newContent);
37.         System.out.println(content);
38.     }
39. }

复制代码

3.PatternSyntaxException

PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

三、分组、捕获、反向引用

1.分组

我们可以用圆括号组成一个比较复杂的匹配模式，那么一个圆括号的部分我们可以看作是一个子表达式/一个分组。

2.捕获

把正则表达式中子表达式/分组匹配的内容，保存到内存中以数字编号或显式命名的组里，方便后面引用，从左向右，以分组的左括号为标志,第一个出现的分组的组号为1，第二个为2，以此类推。组0代表的是整个正则式

3.反向引用

圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以是在正则表达式内部,也可以是在正则表达式外部,内部反向引用\\分组号，外部反向引用$分组号

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp12 {
10.     public static void main(String[] args) {
11.         String content = "hel522511lo d1234111dd h55ell3o dsa$ hello";
12.         //匹配连续相同的两个数字
13.         //String regStr = "(\\d)\\1";
14.         //String regStr = "(\\d)\\1{1}";
15.         //String regStr = "(\\d)(\\d)";
17.         //匹配连续三个相同的字符
18.         //String regStr = "(\\d)\\1{2}";
20.         //匹配个位与千位相同十位与百位相同的字符 如：1221
21.         String regStr = "(\\d)(\\d)\\2\\1";
23.         Pattern pattern = Pattern.compile(regStr);
24.         Matcher matcher = pattern.matcher(content);
26.         while(matcher.find()){
27.             System.out.println("找到:"+matcher.group(0));
28.         }
29.     }
30. }

复制代码

个人理解反向引用就是通过分组的组名去再次利用分组

四、正则表达式应用

1.简单应用

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp08 {
10.     public static void main(String[] args) {
12.         //汉字范围
13. //        String content = "芊嵛要天天进步呀";
14. //        String regStr = "^[\\u4E00-\\u9FA5]+$";
16.         //邮政编码  0-9组成的6位数
17. //        String content = "123456";
18. //        String regStr = "^\\d{6}$";
21.         //QQ号   1-9开头的
22.         String content = "10006";
23.         String regStr = "^[1-9][0-9]{4,10}$";
25.         Pattern pattern = Pattern.compile(regStr);
26.         Matcher matcher = pattern.matcher(content);
28.         if(matcher.find()){
29.             System.out.println("满足格式");
30.         }else{
31.             System.out.println("不满足格式");
32.         }
33.     }
34. }

复制代码

2.判断url

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp09 {
10.     public static void main(String[] args) {
11.         String content = "https://space.bilibili.com/327811521?spm_id_from=333.1007.0.0";
13.         /**
14.          * 1.先用((http|https)://)确定url的开始部分 http:// | https://
15.          * 2.再用([\w-]+\.)+[\w-]+确定space.bilibili.com
16.          * 3.再用[\w-]+(\/[\w-?=&/%.]*)?确定/327811521?spm_id_from=333.1007.0.0
17.          *
18.          * 说明[]里面的东西都会是原样的
19.          */
20.         String regStr = "^((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.]*)?$";
22.         Pattern pattern = Pattern.compile(regStr);
23.         Matcher matcher = pattern.matcher(content);
25.         if(matcher.find()){
26.             System.out.println("满足格式");
27.         }else{
28.             System.out.println("不满足格式");
29.         }
30.     }
31. }

复制代码

3.结巴去重

1. package com.qy.regexp;
3. import java.util.regex.Matcher;
4. import java.util.regex.Pattern;
6. /**
7. * @auther QY
8. */
9. public class RegExp13 {
10.     public static void main(String[] args) {
11.         String content = "我....我要....学学学学...编程java!";
13.          //1.去掉所有.(我我要学学学学编程java!)
16.         Pattern pattern = Pattern.compile("\\.");
17.         Matcher matcher = pattern.matcher(content);
18.         content = matcher.replaceAll("");
20.         System.out.println(content);
22.         //2.去掉重复的字
23.         //使用反向引用$1来替换匹配到的内容
24.         content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
25.         System.out.println(content);
26.     }
27. }

复制代码

说明：
为什么一个$1就可以替换不同的字符呢，为什么不只是替换第一个字符，可能你有这样的疑问，
解释：这还要看源码，通过源码我们可以得知分组的位置不是递增的而是一次一次被替换的，因此他始终会在1分组，开始我在1分组中，然后用我替换了全部连续的我，之后要替换我进入第一个分组，重复上述操作等等

4.分割字符串

1. package com.qy.regexp;
3. /**
4. * @auther QY
5. */
6. public class RegExp14 {
7.     public static void main(String[] args) {
8.         String content = "qy#dha-jd=你好=aj?d51~ddd";
9.         String[] split = content.split("#|-|~|\\d+|=|\\?");
10.         for (String i :split){
11.             System.out.println(i);
12.         }
13.     }
14. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！