《正则表达式》第1节：正则表达式入门

Posted 2023-01-03

​正则表达式能够定义一个字符串的格式，读者也可以理解为定义一个字符串的结构特征，例如定义一个电子邮件地址的结构特征等。而书写正则表达式需要使用一些有特殊含义的符号，专业上把这种有特殊含义的符号称为“通配符”这些通配符有的代表数字，有的代表字母，因此使用通配符可以很容易的定义出如连续的3个数字、连续的8个字母这样的特定格式，本小节将讲解如何使用这些通配符。

16.1.1通配符

Java语言中表示字符串的String类的很多方法都以正则表达式作为参数，正因如此，调用这些方法时需要特别注意正则表达式的通配符，否则会导致程序运行的运行结果与预期不相符，请看下面的【例16_01】。​

【例16_01通配符】

Exam16_01.java​

public class Exam16_01 
    public static void main(String[] args) 
        String str = "he.llo world.";
        String result = str.replaceAll(".","-");
        System.out.println(result);
    

本例中，程序员希望调用String类的replaceAll()方法把字符串中的“.”全部替换为“-”，但程序的运行结果如图16-1所示。​

图16-1【例16_01】运行结果​

从图16-1可以很明显的看出程序的运行结果并没有达到预期，这是因为replaceAll()方法的第一个参数的名称是regex，这个参数的名称表示它是一个正则表达式，而在正则表达式中“.”是一个通配符，它表示除换行符（\\n）之外的所有字符，因此程序中replaceAll()方法实际上是把字符串“he.llo world.”中的每一个字符都替换为“-”，因此才出现了图16-1所示的运行结果。正则表达式中的通配符有很多，如表16-1所示。​

表16-1 正则表达式的通配符​

符号​	含义​
\\d​	匹配一个数字字符，既0~9当中的一个​
\\D​	匹配一个非数字字符​
\\w​	匹配任意一个数字、字母和下划线​
\\W​	匹配所有\\w不匹配的字符​
\\s​	匹配空白字符，包括空格、制表符、换页符等​
\\S​	匹配所有\\s不匹配的字符​
.​	匹配除换行符(\\n)之外的所有字符，1个.仅能匹配1个字符​

专业上把希望完成匹配的子字符串称为“目标字符串”，按照表16-1所介绍的通配符的功能，程序员可以定义任意格式的目标字符串，下面的【例16_02】展示了如何使用特殊符号完成目标字符串的替换操作。​

【例16_02 替换目标字符串1】

Exam16_02.java​

public class Exam16_02 
    public static void main(String[] args) 
        String str = "3ast1dfj6asdjfpe2utmgnb3qweanki";
        //把数字以及之后的字母a替换为--
        String result = str.replaceAll("\\\\da","--");
        System.out.println( result);
    

【例16_02】中，代表数字的“\\d”被写作“\\\\d”，这是因为“\\”是转义字符的标志，因此“\\”出现在字符串中要被写作“\\\\”。程序中所定义的目标字符串格式是“数字与字母a的组合”，使用正则表达式书定义这个目标字符串的格式就是“\\\\da”。可以看出：str中包含的“3a”和“6a”都符合这个格式，这样的组合会被统一替换成“--”。【例16_02】的运行结果如图16-2所示。​

图16-2【例16_02】运行结果​

从图16-2可以看出：只有数字与字母a的组合被替换为--，而数字与其他字母的组合都没有被替换。需要强调：“\\d”代表的是一个数字字符，而不能代表一个数学意义上的数字，例如数学意义上的数字13实际上是两个数字字符组成的，因此“\\d”不能代表数字13。​

表16-1中的“\\w”能匹配数字、字母和下划线，其中字母不分大小写，都能完成匹配。“\\W”的意义恰好与“\\w”相反，它匹配的是“\\w”所不能匹配的其他字符。下面的【例16_03】展示了“\\w”和“\\W”的效果。​

【例16_03 替换目标字符串2】

Exam16_03.java​

public class Exam16_03 
    public static void main(String[] args) 
        String str = "你1好2*#abc以及A_B&&";
        String result1 = str.replaceAll("\\\\w","-");//①
        String result2 = str.replaceAll("\\\\W","@");//②
        System.out.println(result1);
        System.out.println(result2);
    

【例16_03】中，语句①是把字符串str中的所有数字、字母和下划线都替换为“-”，而语句②则是把str中那些不能被“\\w”所匹配的字符全部替换为“@”，【例16_03】的运行结果如图16-3所示。​

图16-3【例16_03】运行结果​

从图16-3可以看出：汉字不能被“\\w”所匹配。​

在众多通配符中，只有“.”不是以“\\”开头的，如果希望在完成匹配的过程中把“.”当做一个普通字符，那么就需要把“.”写成“\\\\.”，下面的【例16_04】展示了把“.”还原为一个普通字符的方法。​

【例16_04 还原特殊符号】

Exam16_04.java​

public class Exam16_04 
    public static void main(String[] args) 
        String str = "he.llo world.";
        //把str中的.替换为-
        String result = str.replaceAll("\\\\.","-");
        System.out.println(result);
    

【例16_04】中，语句①定义的目标字符串格式为“\\\\.”，这就表示要匹配“.”而不是任意一个字符。【例16_04】的运行结果如图16-4所示。​

图16-4【例16_04】运行结果​

16.1.2自定义通配符

16.1.1小节介绍的这些通配符当中有的能够匹配数字字符，有的可以匹配空白字符，它们各自都有一定的作用。但是，如果程序员想匹配某些特定的字符，例如只匹配abcd这四个字母中的一个，这就需要用到正则表达式的自定义通配符。自定义通配符由一对中括号（[]）定义，也就是说程序员只要在一对中括号中写上一些字符，这些字符中的任意一个都会被当作匹配目标。下面的【例16_05】展示了自定义通配符的用法。​

【例16_05 自定义通配符】

Exam16_05.java​

public class Exam16_05 
    public static void main(String[] args) 
        String str = "abcd7ab3exga]8wgqea%6qmv-ku";
        String result = str.replaceAll("[abcd]","*");
        System.out.println(result);
    

【例16_05】中，replaceAll ()方法的第一个参数是“[abcd]”，这是一个自定义的通配符，它能匹配abcd中任意一个字母。replaceAll ()方法的第二个参数是“*”，这样的话字符串str中的a、b、c、d这些字母都会被替换为*，【例16_05】的运行结果如图16-5所示。​

图16-5【例16_05】运行结果​

从图16-5可以看出：字符串中的a、b、c、d这些字母都被替换为了*。需要强调：[abcd]代表a、b、c、d中的任意一个字母不是代表“abcd”这个字符串，正因如此，字符串str开头的abcd被替换为4个“*”而不是一个“*”。​

如果自定义通配符中定义的字符范围是一组连续的字符，程序员也可以只写出这组字符的开头和结尾，中间用一个“-”把开头和结尾连接起来，例如“[abcd]”也可以写成“[a-d]”。需要注意：在用“-”连接两个字符的时候，一定要把编码小的字符写在左边，而把编码大的字符写在右边，否则在程序运行时会抛出异常。如果自定义通配符中的字符范围是两组连续的字符，也可以直接把两组连续的字符都写出来，中间不用任何符号分隔这两个组，例如希望自定义的通配符能够匹配a、b、c、d以及x、y、z，就可以把自定义通配符写为“[a-dx-z]”。如果两个组中间如果出现了一些其他字符也是可以的，比如“[a-dqvx-z]”，这个自定义通配符能够匹配a、b、c、d、q、v、x、y、z这几个字符。​

如果希望自定义通配符也能匹配“-”这个字符，该怎么定义这个通配符呢？这时候要分两种情况讨论，如果表达式引擎能够认定这个“-”是一个普通字符，那么就直接在方括号中写上“-”本身就可以，否则就需要把“-”写成转义字符的形式。例如有自定义通配符“[a-]”，在这个自定义通配符中，由于“-”后面没有任何字符，表达式引擎会把“-”当作普通字符，而这个自定义的通配符可以匹配“a”和“-”。如果希望自定义通配符能够匹配“a”、“-”和“d”，这种情况下假设把自定义通配符写为“[a-d]”，那么表达式引擎会认为这个自定义通配符能够匹配a、b、c、d，与期望的语义不同，因此需要用转义字符的形式把自定义通配符写为“[a\\\\-d]”。​

自定义通配符由[]定义，如果需要让自定义通配符匹配“[”和“]”该怎么办呢？表达式引擎处理这两个字符的策略并不一样。表达式引擎允许“]”直接出现在自定义通配符中，例如“[]x]”这个自定义通配符可以匹配“]”或“x”。但是需要注意：如果把刚才的自定义通配符写为“[x]]”，在这种情况下“[x]]”就已经不再是一个单独的自定义通配符了，而是变成了自定义通配符和“]”的组合。这个组合中，只有“[x]”是自定义通配符，而这个自定义通配符只能匹配“x”，而“]”也只能匹配“]”，所以“[x]]”这个组合匹配的是“x]”而不是“]”或“x”。因此，如果希望自定义通配符中包含“]”，就应该把它写作最左边，否则就要用转义字符的形式书写它。​

表达式引擎对于“[”的处理策略是干脆不允许它直接出现在自定义通配符当中，必须以转义字符的形式出现。例如希望定义一个能够匹配“[”或“x”，需要把自定义通配符写为“[\\\\[x]”。​

如果程序员定义的通配符是希望它能够匹配某些字符以外的其他字符，那么就需要用“[^]”的形式来定义，例如希望自定义的通配符能够匹配除a、b、c、d这四个字符以外的其他任何字符就可以把自定义通配符写为“[^abcd]”。读者可以尝试把【例16_05】中语句①的“[abcd]”改成“[^abcd]”后再次运行程序并观察运行效果。此外还可以看出：在正则表达式中“^”也是一个特殊符号，如果希望表示其原本语义，也需要用转义字符的形式书写。​

16.1.3还原特殊符号

正则表达式中的特殊符号一般都是通配符，但有时候需要把字符串中出现的这些特殊符号替换成其他字符，此时就需要用转义字符的形式书写这些特殊符号，例如：​

String str = "..a..**a**";​
String result = str.replaceAll("\\\\.\\\\.a\\\\.\\\\.","@");​

上面这段代码是把字符串str中的“..a..”替换为“@”，由于“.”在正则表达式中可以匹配除换行符外的任意字符，因此需要在replaceAll()方法的第一个参数中以转义字符的形式书写，也就是写为“\\\\.”，如果不这样写，那么str中的“**a**”也会被替换为“@”。读者不难发现：如果一个正则表达式中大量出现转义字符，会使正则表达式中出现大量“\\\\”从而导致表达式变得过于繁琐。为解决这个问题，正则表达式引入了“特殊字符失效区”。所谓“特殊字符失效区”是一片区域，在这片区域中特殊字符将被还原成普通字符。​

特殊字符失效区以“\\Q”作为开头，以“\\E”作为结尾，在实际书写时要写为“\\\\Q”和“\\\\E”，正则表达式中“\\Q”和“\\E”之间出现的特殊字符都会被表达式引擎当作普通字符，下面的【例16_06】展示了特殊字符失效区的作用。​

【例16_06 特殊字符失效区】

Exam16_06.java

public class Exam16_06 
    public static void main(String[] args) 
        String str = "..a..**a**";
        String result1 = str.replaceAll("\\\\Q..a..\\\\E","@");// ①
        String result2 = str.replaceAll("..a..","@");//②
        System.out.println(result1);
        System.out.println(result2);
    

【例16_06】的运行结果如图16-6所示。​

图16-6【例16_06】运行结果​

从图16-6可以很明显的看出：在语句①设置的特殊字符失效区中，通配符被还原成了普通字符。而语句②没有设置特殊字符失效区，通配符“.”匹配任意字符，所以导致str中的“**a**”也会被替换为“@”。​

16.1.4定义出现次数

通配符能够表示某一类型的字符，例如“\\d”表示数字。如果希望把字符串中连续的3个数字替换为一个“*”，要把代码写为：​

String s = "123a234b";​
String r = s.replaceAll("\\\\d\\\\d\\\\d","*");​

以上代码虽然能达到目的，但假如需求发生了变化，要求在一个字符串中找到连续的100个数字，则需要把“\\d”写100遍，这样不仅仅非常麻烦，而且可读性极差。程序员很难检查“\\d”的数量是不是正确。这种情况下就要求以一种更合理的方式定义某类特定字符出现的次数。​

正则表达式以一对大括号定义特定字符的出现次数，程序员在大括中写上特定字符出现次数即可，例如希望把连续出现3个数字替换为一个“*”，就可以把代码写为：​

String s = "123a2345b";​
String r = s.replaceAll("\\\\d3","*");​

如果字符串中连续出现的数字超过3个，则把每3个数字组成一组，不够3个数字的部分不做替换。下面的【例16_07】展示了如何在正则表达式中定义特定字符的出现次数​

【例16_07 定义出现次数1】

Exam16_07.java​

public class Exam16_07 
    public static void main(String[] args) 
        String str = "123a2345b";
        String result = str.replaceAll("\\\\d3","*");
        System.out.println(result);
    

【例16_07】的运行结果如图16-7所示。​

图16-7【例16_07】运行结果​

【例16_07】中的字符串str包含“123”和“2345”两个子子字符串，它们当中的数字都达到了3个，在进行替换时会把“123”替换为一个“*”，而“2345”中“234”恰好是连续的3个数字，它们会被替换我一个“*”，而剩下的“5”不是3个连续的数字，因此不能被替换。​

有的时候，并不一定要求被匹配的字符一定是恰好出现多少次，而是把出现的次数规定为一个范围，比如说，希望数字连续出现3次到5次都能匹配成功，这种情况下可以在大括号中写两个数字，这两个数字之间用逗号隔开，用这两个数字来表示特定字符最少出现多少次，以及最多出现多少次，例如：​

String str = "123a2345b";​
String result = s.replaceAll("\\\\d3,5","*");​

下面的【例16_08】展示了如何把出现次数定义成一个范围以及表达式引擎如何完成匹配。​

【例16_08定义出现次数2】

Exam16_08.java​

public class Exam16_08 
    public static void main(String[] args) 
        String str = "123a234567b";
        String result = str.replaceAll("\\\\d2,3","*");
        System.out.println(result);
    

【例16_08】中的replaceAll()方法希望把2~3个连续的数字替换为一个“*”。可以看出：str包含“123”，如果按照2个数字进行匹配，则“12”会被替换为一个“*”，“3”会被保留，而如果按照3个数字进行匹配，则“123”会被替换为一个“*”。同理，如果按照2个数字进行匹配，“234567”会被替换为3个“*”，但按照3个数字进行匹配“234567”会被替换为2个“*”。【例16_08】的运行结果如图16-8所示。​

图16-8【例16_08】运行结果​

从图16-8可以看出：在完成匹配时都是按3个字符进行匹配的，因此可以得出结论：当规定了出现次数是一个范围时，表达式在每次进行匹配都尽量把更多的目标字符包含进来，也可以理解为：尽量用更多的字符来完成一次匹配。​

如果把大括号中第二个数字去掉，则表示特定字符出现的次数没有上限，例如：​

String str = "123a2345b";​
String result = s.replaceAll("\\\\d3, ","*");​

以上这段代码表示要把连续的3个或以上的数字替换为一个“*”，字符串str中的“123”和“2345”都符合这个替换条件，因此它们都会被替换为“*”。​

定义出现次数也有一些有特定含义的符号，如表16-2所示。​

表16-2 表示出现次数的符号​

符号​	意义​
? ​	出现0次或者1次，相当于0,1​
*​	至少出现0次，相当于0,​
+​	子字符串至少出现1次，相当于1,​
()​	括号中的表达式作为整体​
|​	|两侧的表达式以或者关系存在​

下面的【例16_09】展示了表16-2中所列符号的作用。​

【例16_09定义出现次数3】​

Exam16_09.java​

public class Exam16_09 
    public static void main(String[] args) 
        String str1 = "12ab34c";
        String str2 = "ababbbc";
        String str3 = "Tom and Jack are my friends,but Perter is not.";
        String result1 = str1.replaceAll("\\\\d?","*");//①
        String result2 = str1.replaceAll("\\\\d*","*");//②
        String result3 = str1.replaceAll("\\\\d+","*");//③
        String result4 = str2.replaceAll("ab+","*");//④
        String result5 = str2.replaceAll("(ab)+","*");//⑤
        String result6 = str3.replaceAll("Tom|Jack","*");//⑥
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
        System.out.println(result5);
        System.out.println(result6);
    

【例16_09】的运行结果如图16-9所示。​

图16-9【例16_09】运行结果​

下面对每条语句的运行结果进行逐一解释。语句①中，?表示出现次数为0或1。str1开头的1和2恰好都是一个数字字符，它们完成匹配，因此1和2就被替换成了“*”。在2的后面是字母a，字母a不是数字，当然不能完成匹配。在数字2和字母a之间什么都没有，但表达式引擎认为：什么都没有就等同于出现了0个数字，所以也能完成匹配，因此数字2和字母a之间就又出现了一个可以匹配的字符，虽然这个字符事实上是不存在的，但它仍然被替换成了一个“*”，这样，表示替换结果的result1的开头就出现了3个星号。按照同样的道理，就可以解释为什么字母c之前只有两个数字却被替换为3个“*”。此外，在字母a和b之间本来什么都没有，但最终result1中ab之间却出现了一个“*”。字符串str1的结尾本来是一个字母c，在result1中字母c的后面也出现了一个“*”，就是因为表达式引擎认为字母c的后面什么都没有，就是出现了0个数字。事实上，一个字符的后面不是数字，表达式引擎都会认为这个字符后面有0个数字，所以都会把它替换成星号。​

语句②中，*表示出现次数为0到正无穷。由于每次匹配尽量包含更多的字符，所以字符串开头的12会被当作一个整体完成一次匹配，12与字母a之间没有字符，并且a不是数字，表达式引擎认为这里有0个数字，也会完成一次匹配。这样，当完成替换之后，字母a的前面就会有两个“*”。同理，字母a后面的34会被替换为一个星号，数字4和字母b之间也有0个字符，它也会被替换成“*”，这样完成替换之后字母b后面就会有两个“*”。再往后，字母c的后面也都有0个字符，都会被替换成一个“*”。​

语句③中，+表示出现1到正无穷，只有出现数字的地方才会被替换成“*”，而两个字母之间的“缝隙”不会被替换成一个“*”，因此表示运行结果的result3中只有数字出现的地方才会被替换为“*”，并且连续出现的数字会被作为整体替换为一个“*”。​

语句④中的正则表达式是“ab+”，需要注意：+只用来描述b的出现次数，并不负责描述前面的字母a，因此“ab+”表示“a后面至少有1个b”，因此str2中的“ab”和“abbb”都会被替换为一个“*”。​

语句⑤中的()表示一个整体，因此“(ab)+”表示“ab”出现1次或多次，而str2中的“abab”恰好能与“(ab)+”匹配，所以它被替换为“*”。​

语句⑥中的|表示“或者”的意思，因此语句中的“Tom|Jack”表示“Tom或Jack”会被替换为*。

本文字版教程还配有更详细的视频讲解，小伙伴们可以​​点击这里​​观看。