我是灼灼，一只初学Java的大一金渐层。
向往余秀华和狄兰·托马斯的疯狂，时常沉溺于将情感以诗相寄；追逐过王尔德、王小波的文字，后陷于毛姆和斯蒂芬·金不可自拔；热爱文学的浪潮，白日梦到底却总在现实里清醒；艳羡平静又极度渴盼奔跑的力量。
欢迎与我交流鸭· QQ:1517526827；
个人博客：https://blog.csdn.net/weixin_52777510?spm=1001.2101.3001.5343

正则表达式

正则表达式是一种用来匹配字符串的强有力的武器。Java内置了强大的正则表达式的支持。
内容来自廖雪峰官方Java教程~

文章目录

正则表达式

正则表达式简介

通过程序判断输入是否正确（比如笔者正在学习的注册功能的实现），这种方法需要为每种用例创建规则，然后用代码实现。下面是判断手机号的代码（其实也挺好使的）：

boolean isValidMobileNumber(String s) {
    // 是否是11位？
    if (s.length() != 11) {
        return false;
    }
    // 每一位都是0~9：
    for (int i=0; i<s.length(); i++) {
        char c = s.charAt(i);
        if (c < '0' || c > '9') {
            return false;
        }
    }
    return true;
}

上述代码仅仅做了非常粗略的判断，并未考虑**首位数字不能为0**等更详细的情况（用作一般情况也还行）。

除了判断手机号，还需要判断电子邮件地址、电话、邮编等等（这个奇奇怪怪的命名法看看就好，你想改也可以改的）：

boolean isValidMobileNumber(String s) { … }
boolean isValidEmail(String s) { … }//这个如果是创建规则的话可以参考学长之前写的Java基础知识String类里的一个方法。
boolean isValidPhoneNumber(String s) { … }
boolean isValidZipCode(String s) { … }
…

为每一种判断逻辑编写代码太繁琐了。更简单的方法是用正则表达式！

正则表达式可以用字符串来描述规则，并用来匹配字符串。例如，判断手机号，用正则表达式\d{11}（这个方法其实也不能判断首位是否为零…）：

boolean isValidMobileNumber(String s) {
    return s.matches("\\d{11}");
}

使用正则表达式的好处：

一个正则表达式就是一个描述规则的字符串，所以，只需要编写正确的规则，我们就可以让正则表达式引擎去判断目标字符串是否符合规则。

正则表达式是一套标准，它可以用于任何语言。

Java标准库的java.util.regex包内置了正则表达式引擎。

例子：要判断用户输入的年份是否是20##年，先写出规则如下：

一共有4个字符，分别是：2，0，0~9任意数字，0~9任意数字。

对应的正则表达式就是：20\d\d，其中\d表示任意一个数字。

把正则表达式转换为Java字符串就变成了20\\d\\d，注意Java字符串用\\表示\。

最后，用正则表达式匹配一个字符串的代码如下：

public class Main {
    public static void main(String[] args) {
        String regex = "20\\d\\d";
        System.out.println("2019".matches(regex)); // true
        System.out.println("2100".matches(regex)); // false
    }
}

使用正则表达式，不必编写复杂的代码来判断，只需给出一个字符串表达的正则规则即可。

小结

正则表达式是用字符串描述的一个匹配规则，使用正则表达式可以快速判断给定的字符串是否符合匹配规则。Java标准库java.util.regex内建了正则表达式引擎。

匹配规则

正则表达式的匹配规则是从左到右按规则匹配。

使用正则表达式来做精确匹配：

匹配英文字母

对于正则表达式abc来说，它只能精确地匹配字符串"abc"；

匹配特殊字符

如果正则表达式有特殊字符，那就需要用\转义。

要注意正则表达式在Java代码中也是一个字符串（要加上双引号”“），所以，对于正则表达式a\&c来说，对应的Java字符串是"a\\&c"，因为\也是Java字符串的转义字符，两个\\实际上表示的是一个\，一般写作名为regex；

匹配中文等非ASCII字符

用\u####的十六进制表示

例如：a\u548cc匹配字符串"a和c"，中文字符和的Unicode编码是548c。

匹配任意字符

精确匹配实际上用处不大，因为直接用String.equals()就可以做到。大多数情况下，想要的匹配规则更多的是模糊匹配。

可以用.匹配一个任意字符（英文数字或特殊字符均可）

例如：

正则表达式a.c中间的.可以匹配一个任意字符；
.匹配一个字符且仅限一个字符。

匹配数字

如果想匹配**0~9**这样的数字，可以用\d匹配。
\d仅限单个数字字符。

匹配常用字符

用\w可以匹配一个字母、数字或下划线，w的意思是word。
\w不能匹配**#、空格**等字符。

匹配空格字符

用\s可以匹配一个空格字符，注意空格字符不但包括空格``，

还包括tab字符（在Java中用\t表示）。

匹配非数字

用\d可以匹配一个数字，而\D则匹配一个非数字。

类似的，\W可以匹配\w不能匹配的字符，\S可以匹配\s不能匹配的字符,它们正好是反着来的。

重复匹配（写作A\d修饰）

用\d可以匹配一个数字，如果要匹配多个数字？

修饰符*可以匹配任意个字符，包括0个字符

修饰符+可以匹配至少一个字符（就是不包括0个）

修饰符+要求至少一个字符（这里注意"A"是零个字符！）。

修饰符?可以匹配0个或一个字符

修饰符?超过1个字符就不能匹配了（注意A33是两个字符！）

如果想精确指定n个字符用修饰符{n}。（1个数字就是一个字符）

如果想指定匹配n~m个字符用修饰符{n,m}

如果没有上限，那么修饰符{n,}就可以匹配至少n个字符。

小结

单个字符的匹配规则如下：

正则表达式	规则	可以匹配
`A`	指定字符	`A`
`\u548c`	指定Unicode字符	`和`
`.`	任意字符	`a`，`b`，`&`，`0`
`\d`	数字0~9	`0`~`9`
`\w`	大小写字母，数字和下划线	`a`_`z`，`A``Z`，`0`~`9`，`_`
`\s`	空格、Tab键	空格，Tab
`\D`	非数字	`a`，`A`，`&`，`_`，……
`\W`	非\w	`&`，`@`，`中`，……
`\S`	非\s	`a`，`A`，`&`，`_`，……

多个字符的匹配规则如下：

正则表达式	规则	可以匹配
`A*`	任意个数字符	空，`A`，`AA`，`AAA`，……
`A+`	至少1个字符	`A`，`AA`，`AAA`，……
`A?`	0个或1个字符	空，`A`
`A{3}`	指定个数字符	`AAA`
`A{2,3}`	指定范围个数字符	`AA`，`AAA`
`A{2,}`	至少n个字符	`AA`，`AAA`，`AAAA`，……
`A{0,3}`	最多n个字符	空，`A`，`AA`，`AAA`

复杂匹配规则

匹配开头和结尾

用正则表达式进行多行匹配时，用^表示开头，$表示结尾。

例如，^A\d{3}$表示以A开头，以三个数字字符结尾。

匹配指定范围

如果规定一个7~8位数字的电话号码****不能以0开头，匹配规则怎么写？

使用[...]可以匹配范围内的字符

两种写法表示不为零的一个数：

[123456789]

``[1-9]`

[...]还有一种排除法，即不包含指定范围的字符。假设要匹配任意字符，但不包括数字，可以写[^1-9]{3}（注意这里的三个字符包括下面的A）：

可以匹配"ABC"，因为不包含字符1~9；

可以匹配"A00"，因为不包含字符1~9；

不能匹配"A01"，因为包含字符1；

要匹配大小写不限的十六进制数，比如1A2b3c，可以这样写：[0-9a-fA-F]，它表示一共可以匹配以下任意范围的字符（这6个字符表示的是一个十六进制数）：

0-9：字符0~9；
a-f：字符a~f；
A-F：字符A~F。

如果要匹配6位十六进制数写作[0-9a-fA-F]{6}。

或规则匹配

用|连接的两个正则规则是或规则，例如，AB|CD表示可以匹配AB或CD。

使用括号

要匹配字符串learn java、learn php和learn go?

一个最简单的规则是learn\\sjava|learn\\sphp|learn\\sgo；

简化后可以把公共部分提出来，然后用(...)把子规则括起来表示成learn\\s(java|php|go)。

[这里注意该规则是不能区分大小写来精确匹配的！]

小结

复杂匹配规则主要有：

正则表达式	规则	可以匹配
^	开头	字符串开头
$	结尾	字符串结束
[ABC]	[…]内任意字符	A，B，C
[A-F0-9xy]	指定范围的字符	`A`，……，`F`，`0`，……，`9`，`x`，`y`
[^A-F]	指定范围外的任意字符	非`A`~`F`
AB\|CD\|EF	AB或CD或EF	`AB`，`CD`，`EF`

分组匹配

(...)可以用来把一个子规则括起来，这样可以更方便地匹配长字符串。

(...)还有一个重要作用，就是分组匹配。

如何用正则匹配区号-电话号码这个规则。利用前面讲到的匹配规则，写出来是：

\d{3,4}\-\d{6,8}

虽然这个正则匹配规则很简单，但是往往匹配成功后，下一步是提取区号和电话号码，分别存入数据库，如何提取匹配的子串？

可以用String提供的indexOf()和substring()这些方法，但它们从正则匹配的字符串中提取子串没有通用性，下一次要提取还需要改代码。

正确的方法是：

用(...)先把要提取的规则分组（就是加上小括号隔开），把上述正则表达式变为(\d{3,4})\-(\d{6,8})。
匹配后按括号提取子串：

现在无法用String.matches()这样简单的判断方法，必须引入java.util.regex包，用Pattern对象匹配，匹配后获得一个Matcher对象，如果匹配成功，就可以直接从Matcher.group(index)返回子串（两个子串1和2）；

import java.util.regex.*;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
        Matcher m = p.matcher("010-12345678");
        if (m.matches()) {
            String g1 = m.group(1);
            String g2 = m.group(2);
            System.out.println(g1);
            System.out.println(g2);
        } else {
            System.out.println("匹配失败!");
        }
    }
}

运行上述代码会得到两个匹配上的子串010和12345678。

特别注意，Matcher.group(index)方法的参数用1表示第一个子串，2表示第二个子串。如果传入0会得到010-12345678，即整个正则匹配到的字符串。

Pattern

在前面的代码中用到的正则表达式代码是String.matches()方法，而在分组提取的代码中用的是java.util.regex包里面的Pattern类和Matcher类。实际上这两种代码本质上是一样的，因为String.matches()方法内部调用的就是Pattern和Matcher类的方法。

但是反复使用String.matches()对同一个正则表达式进行多次匹配效率较低，因为每次都会创建出一样的Pattern对象。完全可以先创建出一个Pattern对象，然后反复使用，就可以实现编译一次，多次匹配：

import java.util.regex.*;

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*)，【表示至少一个数字，末尾有任意个0】Java代码如下：

import java.util.regex.*;
public class Main {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(\\d+)(0*)");
        Matcher matcher = pattern.matcher("1230000");
        if (matcher.matches()) {
            System.out.println("group1=" + matcher.group(1)); // "1230000"
            System.out.println("group2=" + matcher.group(2)); // ""
        }
    }
}
然而打印的第二个子串是空字符串""。

实际上，期望分组匹配结果是：

input \d+ 0*

123000 “123” “000”

10100 “101” “00”

1001 “1001” “”

但实际的分组匹配结果是这样的：

input \d+ 0*

123000 “123000” “”

10100 “10100” “”

1001 “1001” “”

仔细观察上述实际匹配结果，实际上它是完全合理的，因为\d+确实可以匹配后面任意个0。

input	`\d+`	`0*`
123000	“123”	“000”
10100	“101”	“00”
1001	“1001”	“”

input	`\d+`	`0*`
123000	“123000”	“”
10100	“10100”	“”
1001	“1001”	“”

因为正则表达式默认使用贪婪匹配：任何一个规则，它总是尽可能多地向后匹配，因此，\d+总是会把后面的0包含进来。

要让\d+尽量少匹配，让0*尽量多匹配，就必须让\d+使用非贪婪匹配。

在规则\d+后面加个?即可表示非贪婪匹配

改写正则表达式后即可实现啦~

给定一个匹配规则，加上?后就变成了非贪婪匹配。

！正则表达式(\d??)(9*)，注意\d?表示匹配0个或1个数字，后面第二个?表示非贪婪匹配，给定字符串"9999"，匹配到的两个子串分别是""和"9999"，因为对于\d?来说，可以匹配1个9，也可以匹配0个9，但是因为后面的?表示非贪婪匹配，它就会尽可能少的匹配，结果匹配了0个9。

小结

正则表达式匹配默认使用贪婪匹配，可以使用?表示对某一规则进行非贪婪匹配。

注意区分?的含义：\d??；

搜索和替换

分割字符串

使用正则表达式分割字符串可以实现更加灵活的功能。

String.split()方法传入的是正则表达式。

看下面的代码：

"a b c".split("\\s"); // { "a", "b", "c" }在有空格的地方实现分割
"a b  c".split("\\s"); // { "a", "b", "", "c" }空格也代表了一个字符
"a, b ;; c".split("[\\,\\;\\s]+"); // { "a", "b", "c" }！这个是什么意思？？？【出现一次以上的都会删掉，比如空格和分号】
再举一个例子：
a b c d
lines[0].split("\\s+")分割后数组为du[a] [b] [c] [d]
lines[0].split("\\s+")[2] -->取得分割后的第三个元素c

如果想让用户输入一组标签，然后把标签提取出来：

因为用户的输入往往是不规范的，使用合适的正则表达式，就可以消除多个空格、混合,和;这些不规范的输入，直接提取出规范的字符串。

搜索字符串

使用正则表达式还可以搜索字符串，例子：

import java.util.regex.*;

public class Main {
    public static void main(String[] args) {
        String s = "the quick brown fox jumps over the lazy dog.";
        Pattern p = Pattern.compile("\\wo\\w");
        Matcher m = p.matcher(s);
        while (m.find()) {
            String sub = s.substring(m.start(), m.end());
            System.out.println(sub);
        }
    }
}

获取到Matcher对象后，不需要调用matches()方法（因为匹配整个串肯定返回false），而是反复调用find()方法，在整个串中搜索能匹配上\\wo\\w规则的子串，并打印出来。这种方式比String.indexOf()要灵活得多，因为搜索的规则是3个字符：中间必须是o，前后两个必须是字符[A-Za-z0-9_]。

替换字符串

使用正则表达式替换字符串可以直接调用String.replaceAll()，它的第一个参数是正则表达式，第二个参数是待替换的字符串。例子：

public class Main {
    public static void main(String[] args) {
        String s = "The     quick\t\t brown   fox  jumps   over the  lazy dog.";
        String r = s.replaceAll("\\s+", " ");//出现不止一次的都用一个空格隔开
        System.out.println(r); // "The quick brown fox jumps over the lazy dog."
    }
}

上面的代码把不规范的连续空格分隔的句子变成了规范的句子。灵活使用正则表达式可以大大降低代码量。

反向引用

如果要把搜索到的指定字符串按规则替换，比如前后各加一个xxxx，这个时候，使用replaceAll()的时候，传入的第二个参数可以使用$1、$2来反向引用匹配到的子串。例如：

public class Main {
    public static void main(String[] args) {
        String s = "the quick brown fox jumps over the lazy dog.";
        String r = s.replaceAll("\\s([a-z]{4})\\s", " <b>$1</b> ");//符合空格之间是四个小写字母的匹配后替换
        System.out.println(r);
    }
}

上述代码的运行结果是：

the quick brown fox jumps <b>over</b> the <b>lazy</b> dog.

它实际上是把任何4字符单词的前后用xxxx括起来。实现替换的关键就在于" $1 "，它用匹配的分组子串([a-z]{4})替换了$1。

小结

使用正则表达式可以：

分割字符串：String.split()
搜索子串：Matcher.find()
替换字符串：String.replaceAll()

有关Java中的正则表达式知识就到这里了！
在这里插入图片描述
如果对你有帮助的话不要忘记一键三连噢~
谢谢鸭~

初次编写于2021/2/18日；

【学习笔记】Java中的正则表达式

正则表达式

文章目录

正则表达式简介

小结

匹配规则

匹配任意字符

匹配数字

匹配常用字符

匹配空格字符

匹配非数字

重复匹配（写作A\d修饰）

小结

复杂匹配规则

匹配开头和结尾

匹配指定范围

或规则匹配

使用括号

小结

分组匹配

Pattern

小结

非贪婪匹配

小结

搜索和替换

分割字符串

搜索字符串

替换字符串

反向引用

小结

猜你喜欢