正则表达式概述
简介
正则表达式是一种通用的知识技能，学会后，无论是前端还是后端、无论是Java还是python都会用到，基本上各种编程语言都支持正则表达式。
正则表达式通常用于（替换、校验、检索）：
- 校验字符串。例如，用户输入的电话号码，要求只能是11位数字并且以"13"开头，这时候通过正则表达式来校验非常适合。
- 提取数据。例如，我们使用爬虫的时候爬下来一段字符串，我们要获取里面的一段信息，使用正则表达式来进行匹配提取也是一种合适的方式。
学习
正则表达式初次接触是不太好学习的，但学会之后却是大有帮助。下面提供一些网站用于学习正则表达式：
- 菜鸟教程-正则表达式 ：是一个比较适合学习正则表达式的网站，提供了基本教程。
- Regulex：以图的方式观察正则表达式。
- Learn Regex The Easy Way：GitHub上的一篇学习正则表达式的教程。
- 正则表达式30分钟入门教程：正则表达式入门教程。
- Regex Golf：一个用来练习正则表达式的网站，输入正则表达式来匹配答案。前十道题的答案解析请参考：正则表达式练习之Regex Golf
- REGEXPER：以图的方式观察正则表达式。
- 正则表达式手册：以表格的形式展示了正则表达式，作为查询手册很合适。
正则表达式语法
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
例如：
a+c，可以匹配ac、aaac、aaaaaaac等，+号表示前面的字符至少出现一次。a*c，可匹配c、ac、aac、aaaac等，*号代表前面的字符可以不出现，又可以出现一次或者多次。
构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。
正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
普通字符
普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写字母和小写字母、所有数字、所有标点符号和一些其他符号。
| 字符 | 描述 |
|---|---|
[abc] | 字符集合。匹配所包含的任意一个字符。即等价于[a|b|c]，可以匹配"a"字符或"b"字符或"c"字符。例如，可以匹配"github"中的"b"字符。 |
[123] | 字符集合。匹配所包含的任意一个字符。即等价于[1|2|3]，可以匹配"1"字符或"2"字符或"3"字符。例如，可以匹配"10086"中的"1"字符。 |
[^abc] | 负值字符集合。匹配未包含的任意字符。即待匹配的字符不是"a"或"b"或"c"则都可以匹配。例如，“[^abc]”可以匹配“plain”中的“p”。 |
[a-z] | 字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。其实等价于[abcdefghijklmnopqrstuvwxyz]，因为要写的太多了，所以使用[a-z]概述。其中[0-9]表示匹配任意数字；[A-Z]表示匹配任意大写字母；[a-zA-Z0-9]表示匹配任意大小写字母和数字。 |
[^a-z] | 负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。即不能匹配匹配任意小写字母字符。 |
. | 点字符，匹配除换行符（\n、\r）之外的任何单个字符，相等于[^\n\r]。 |
非打印字符
非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：
| 字符 | 描述 |
|---|---|
| \b | 匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。 |
| \B | 匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。 |
| \cx | 匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。 |
| \d | 匹配一个数字字符。等价于[0-9]。 |
| \D | 匹配一个非数字字符。等价于[^0-9]。 |
| \f | 匹配一个换页符。等价于\x0c和\cL。 |
| \n | 匹配一个换行符。等价于\x0a和\cJ。 |
| \r | 匹配一个回车符。等价于\x0d和\cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。 |
| \S | 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。 |
| \t | 匹配一个制表符。等价于\x09和\cI。 |
| \v | 匹配一个垂直制表符。等价于\x0b和\cK。 |
| \w | 匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。 |
| \W | 匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。 |
特殊字符
所谓特殊字符，就是一些有特殊含义的字符，如*在正则表达式中表示任何字符串的意思，而不是匹配"*"字符，如果要匹配字符串中的"*"字符，则需要对*进行转义，即在前面添加一个\变成\*。许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\ 放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
$ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或'\r'。要匹配$字符本身，请使用\$。 |
( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用\(和\)。 |
* | 匹配前面的子表达式零次或多次。要匹配*字符，请使用\*。 |
+ | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用\+。 |
. | 匹配除换行符 \n 之外的任何单字符。要匹配. ，请使用\.。 |
[ | 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 |
? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配?字符，请使用\?。 |
\ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符'n'。'\n' 匹配换行符。序列'\\'匹配"\"，而'\('则匹配"("。 |
^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配^字符本身，请使用\^。 |
{ | 标记限定符表达式的开始。要匹配 {，请使用 \{。 |
| | 指明两项之间的一个选择。要匹配 |，请使用 \|。 |
限定符
限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有* 或 + 或 ?或 {n} 或 {n,} 或 {n,m} 共6种。正则表达式的限定符有：
| 字符 | 描述 |
|---|---|
* | 匹配前面的子表达式零次或多次，即匹配次数>=0。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。 |
+ | 匹配前面的子表达式一次或多次，即匹配次数>=1。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z。+ 等价于 {1,}。 |
? | 匹配前面的子表达式零次或一次，即匹配次数=0或匹配次数=1。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、"doxy"中的 "do" 。? 等价于 {0,1}。 |
{n} | n 是一个非负整数。匹配确定的 n 次，即匹配次数=n。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。 |
{n,} | n 是一个非负整数。至少匹配n 次，即匹配次数>=n。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。 |
{n,m} | m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次，即n<=匹配次数<=m。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于'o?'。请注意在逗号和两个数之间不能有空格。 |
定位符
定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。
定位符用来描述字符串或单词的边界，^和 $分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。正则表达式的定位符有：
| 字符 | 描述 |
|---|---|
^ | 匹配输入字符串开始的位置。如^hello会匹配以"hello"开头的字符串，可以有hello、helloxxx。 |
$ | 匹配输入字符串结尾的位置。如hello$会匹配以"hello"结尾的字符串，可以有hello、abchello。如^hello$必须完全匹配"hello"字符串。 |
\b | 匹配一个单词边界，即字与空格间的位置。 |
\B | 非单词边界匹配，即与\b相反的含义。 |
注意：
-
不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如
^*之类的表达式。 -
若要匹配一行文本开始处的文本，请在正则表达式的开始使用
^字符。不要将^的这种用法与中括号表达式[]内的用法混淆。 -
若要匹配一行文本的结束处的文本，请在正则表达式的结束处使用
$字符。
分组
用圆括号()将所有选择项括起来，相邻的选择项之间用 |分隔。例如，(hello|hi)可以匹配hello或hi字符串，里面的字符串表示或的关系。
()表示捕获分组，()会把每个分组里的匹配的值保存起来， 多个匹配值可以通过数字 n 来查看(n 是一个数字，表示第n个捕获组的内容)。
反向引用
对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
即使用中括号()括起来的表达式是一个分组，该分组可以继续引用，匹配相同的结果，而要引用这个分组可以通过\n来引用，其中n是分组的编号，从1开始。
通常用来匹配HTML标签非常合适，例如：
贪婪与非贪婪
* 和 + 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个 ?就可以实现非贪婪或最小匹配。
我们用下面的HTML标签来体现贪婪与非贪婪的区别，例如我们搜索HTML文档，查找h1标签内的内容，如下：
<h1>一级标题</h1>
贪婪：表达式<.*>匹配从开始小于符号 (<) 到关闭 h1 标记的大于符号 (>) 之间的所有内容。
非贪婪：如果您只需要匹配开始和结束h1标签，非贪婪表达式<.*?>只匹配 <h1>。又可以使用<\w+?>正则表达式来匹配h1标签。
总结：通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从"贪婪"表达式转换为"非贪婪"表达式或者最小匹配。
断言
正则表达式的先行断言和后行断言一共有 4 种形式：
reg(?=pattern)：零宽正向先行断言，reg匹配的后面内容必须满足pattern正则表达式所表示的规则。reg(?!pattern)：零宽负向先行断言，reg匹配的后面内容必须不满足pattern正则表达式所表示的规则。(?<=pattern)reg：零宽正向后行断言，reg匹配的前面内容必须满足pattern正则表达式所表示的规则。(?<!pattern)reg：零宽负向后行断言，reg匹配的前面内容必须不满足pattern正则表达式所表示的规则。
这里面的 pattern 是一个正则表达式，reg是指定的内容。
零宽断言用于查找在某些内容(但并不包括这些内容)之前或之后的东西。
例如：
(?=\d{3})：表示校验的位置后面必须是3个数字。(?=\d+)：表示校验的位置后面接着的是数字。(?=^.{5}$)：表示校验的位置后面的字符串的长度为5，匹配长度为5的字符串。(?!.*\d{3}.*)：表示校验的位置后面不包含三个连续的数字，筛选出不包含三个连续数字的字符串。(?<=\d{3})：表示校验的位置前面有三个连续的数字。(?<!\d{2})：表示校验的位置前面不能是两个数字。
(?=pattern)正向先行断言
代表字符串中的一个位置，紧接该位置之后的字符序列能够匹配 pattern。即该位置后面的内容必须满足pattern正则表达式。
例如，有一个字符串"a regular expression regex."，要匹配regular中re而非expression中的re和非regex中的re，可以使用正则表达式re(?=gular)，即只匹配regular前面的re。
而断言是零宽的，即(?=pattern)这些断言是不占用位置的。因为re(?=gular)gular完整匹配了"regular"字符串。
(?!pattern)负向先行断言
代表字符串中的一个位置，紧接该位置之后的字符序列不能匹配 pattern。即该位置后面的内容必须不满足pattern正则表达式。
例如，有一个字符串"a regular expression regex."，要匹配regex和expression中re而非regular的re，可以使用正则表达式re(?!gular)，即不匹配regular前面的re。
负向和正向的区别，在于该位置之后的内容是否能匹配括号中的正则表达式。
(?<=pattern)正向后行断言
代表字符串中的一个位置，紧接该位置之前的字符序列能够匹配 pattern。
例如，有一个字符串"a regular expression regex."，要匹配单词中间的re，而非单词开头的re，可以使用正则表达式(?<=\w)re，该表达式表示re的前面应该有一个字符，所以能匹配到expression中的re，而regular和regex的前面都是空格字符，不能被匹配到。
(?<!pattern)负向后行断言
代表字符串中的一个位置，紧接该位置之前的字符序列能够匹配 pattern。
例如，有一个字符串"a regular expression regex."，我们要匹配单词开头的re即regular和regex这样的，而非expression这样在单词中间的re，可以使用这样的正则表达式(?<!\w)re，即re前面没有单词字符，因为regular和regex的前面是空格字符，而expression中的re前面是p字符。
总结：
- 关于先行(lookahead)和后行(lookbehind)：正则表达式引擎在执行字符串和表达式匹配时，会从头到尾（从前到后）连续扫描字符串中的字符，设想有一个扫描指针指向字符边界处并随匹配过程移动。先行断言，是当扫描指针位于某处时，引擎会尝试匹配指针还未扫过的字符，先于指针到达该字符，故称为先行。后行断言，引擎会尝试匹配指针已扫过的字符，后于指针到达该字符，故称为后行。
- 关于正向(positive)和负向(negative)：正向就表示匹配括号中的表达式，负向表示不匹配。
一些正则表达式
[^a]：可以匹配一个字符，表示可以匹配除了a字符之外的任意一个字符。如字符串"access"中的"c"、“c”、“e”、“s”、"s"字符。.{3}[^a]：可以匹配四个字符，.{3}表示可以匹配任意三个字符，而.{3}[^a]中的[^a]表示第四个字符不能是"a"字符。所以如字符串"access"中可以匹配到"acce"，匹配结果中存在"a"字符，但不是在第四个字符的位置，该正则表达式只能限制第四个字符不是"a"，不能限制其他位置的字符是不是"a"。[^a-zA-Z0-9]：可以匹配一个字符，表示匹配一个既不是大写字母又不是小写字母还不是数字的字符，如"!"、"^"这样的字符。^符号在[]中才表示字符的否定，如果不是的话则表示开头。(^cat)$或(^cat$)或^(cat)$或^(cat$)：都表示以"c"字符开头并且以"t"字符结尾，完整匹配字符串"cat"。
正则表达式修饰符
修饰符概述
修饰符又称之为标记，用于指定额外的匹配策略，因为修饰符不写在正则表达式里面，而是位于表达式之外，格式如下：/pattern/flags。
正则表达式常用修饰符如下：
| 修饰符 | 含义 | 描述 |
|---|---|---|
i | ignore - 不区分大小写 | 将匹配设置为不区分大小写，搜索时不区分大小写: A 和 a 没有区别。 |
g | global - 全局匹配 | 查找所有的匹配项。 |
m | multi line - 多行匹配 | 使边界字符 ^ 和 $ 匹配每一行的开头和结尾，记住是多行，而不是整个字符串的开头和结尾。 |
s | 特殊字符圆点 .中包含换行符 \n | 默认情况下的圆点. 是 匹配除换行符 \n之外的任何字符，加上 s 修饰符之后, . 中包含换行符 \n。 |
注意：是可以多个修饰符一起使用的。
g修饰符
g 修饰符可以查找字符串中所有的匹配项。如果添加该修饰符则表示查找所有的匹配项；如果不添加该修饰符则表示只查找第一次匹配项。
i修饰符
i 修饰符为不区分大小写匹配。如果不添加该修饰符则表示匹配会区分大小写；如果添加该修饰符则表示匹配会不区分大小写。
m修饰符
m 修饰符可以使 ^ 和 $ 匹配一段文本中每行的开始和结束位置。在默认状态下，一个字符串无论是否换行只有一个开始^和结尾$，如果采用多行匹配，那么每一个行都有一个^和结尾$。如果不添加该修饰符则只会匹配一行；如果添加该修饰符则会匹配多行。但注意，m修饰符同^和$符号一起使用。
正则表达式总结
该表达式表格来自于：正则表达式手册
| 字符 | 描述 |
|---|---|
\ | 将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。串行“\\”匹配“\”，而“\(”则匹配“(”。 |
^ | 匹配输入字符串的开始位置。如果设置了m修饰符，^也匹配“\n”或“\r”之后的位置（即可以多行匹配）。 |
$ | 匹配输入字符串的结束位置。如果设置了m修饰符，$也匹配“\n”或“\r”之前的位置（即可以多行匹配）。 |
* | 匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0,}。 |
+ | 匹配前面的子表达式一次或多次。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。 |
? | 匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“does”或“does”中的“do”。?等价于{0,1}。 |
{*n*} | n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个"o"。 |
{*n*,} | n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。 |
{n,m} | m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。 |
? | 当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o+”将匹配所有“o”。 |
. | 匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符，请使用像“(.|\n)”的模式。 |
(pattern) | 匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到。要匹配圆括号字符，请使用“\(”或“\)”。 |
(?:pattern) | 匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分是很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。 |
(?=pattern) | 正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 |
(?!pattern) | 正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始 |
(?<=pattern) | 反向肯定预查，与正向肯定预查类拟，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。 |
(?<!pattern) | 反向否定预查，与正向否定预查类拟，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。 |
x|y | 匹配x或y。例如，“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。 |
[xyz] | 字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。 |
[^xyz] | 负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“p”。 |
[a-z] | 字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。 |
[^a-z] | 负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。 |
\b | 匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。 |
\B | 匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。 |
\cx | 匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。 |
\d | 匹配一个数字字符。等价于[0-9]。 |
\D | 匹配一个非数字字符。等价于[^0-9]。 |
\f | 匹配一个换页符。等价于\x0c和\cL。 |
\n | 匹配一个换行符。等价于\x0a和\cJ。 |
\r | 匹配一个回车符。等价于\x0d和\cM。 |
\s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。 |
\S | 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。 |
\t | 匹配一个制表符。等价于\x09和\cI。 |
\v | 匹配一个垂直制表符。等价于\x0b和\cK。 |
\w | 匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。 |
\W | 匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。 |
Java中的正则表达式
Java中使用正则表达式的示例如下：
public class T {
/**
* Pattern类和Matcher类
*/
@Test
public void test() {
// pattern()方法返回正则表达式的字符串形式，其实就是返回Pattern.compile(String regex)的regex参数
Pattern p1 = Pattern.compile("\\d+");
String r1 = p1.pattern();
System.out.println(r1);
// split(CharSequence input)方法用于分割字符串，返回一个String[]
Pattern p2 = Pattern.compile("-");
String[] splits = p2.split("name-age-sex-score");
System.out.println(Arrays.toString(splits));
// Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串
boolean m1 = Pattern.matches("\\d+", "12");// 返回true，因为完整匹配input字符串
System.out.println(m1);
boolean m2 = Pattern.matches("\\d+", "123abcdefg");// 返回false，需要匹配到所有字符串才能返回true，这里"abcdefg"不能匹配到
System.out.println(m2);
boolean m3 = Pattern.matches("\\d+", "123abc456");// 返回false，需要匹配到所有字符串才能返回true，这里"abc"不能匹配到
System.out.println(m3);
// Pattern.matcher(CharSequence input)返回一个Matcher对象。Matcher类提供了对正则表达式的分组支持，以及对正则表达式的多次匹配支持。
Pattern p4 = Pattern.compile("\\d+");
Matcher m4 = p4.matcher("123abc456efg789");
Pattern pattern = m4.pattern();// pattern()方法返回该Matcher对象是由哪个Pattern对象的创建的，打印的结果是Pattern.compile(String regex)中的regex正则表达式
System.out.println(pattern);
// Matcher.matches()方法返回布尔值，当匹配到时返回true，没有匹配到则返回false。matches()方法对整个字符串进行匹配，只有整个字符串都完整匹配了才会返回true。
Pattern p5 = Pattern.compile("\\d+");
Matcher m5 = p5.matcher("123abc456");
System.out.println(m5.matches());// 返回false，因为字符串中"abc"不是数字，不能被匹配到，所以导致整个字符串匹配未成功
Matcher m6 = p5.matcher("123456789");
System.out.println(m6.matches());// 返回true，字符串中都是数字，会匹配到整个字符串
// Matcher.lookingAt()方法返回布尔值，当匹配到时返回true，没有匹配到则返回false。lookingAt()方法对前面的字符串进行匹配，只有匹配到的字符串在最前面才返回true。
Matcher m7 = p5.matcher("123abc456");
System.out.println(m7.lookingAt());// 返回true，因为\d+能匹配到前面的123
Matcher m8 = p5.matcher("abc123efg");
System.out.println(m8.lookingAt());// 返回false，因为\d+不能匹配到前面的"abc"
// Matcher.find()方法返回布尔值，当匹配到时返回true，没有匹配到则返回false。find()方法对字符串进行匹配，匹配到的字符串可以在任何位置
Matcher m9 = p5.matcher("123abc456");
System.out.println(m9.find());// 返回true
Matcher m10 = p5.matcher("abc123efg");
System.out.println(m10.find());// 返回true
Matcher m11 = p5.matcher("abcdef12356");
System.out.println(m11.find());// 返回true
Matcher m12 = p5.matcher("ab");
System.out.println(m12.find());// 返回false
// Matcher.start()方法返回匹配到的子字符串在字符串中的索引位置
// Matcher.end()方法返回匹配到的子字符串的最后一个字符在字符串中的索引位置
// Matcher.group()方法返回匹配到的子字符串
Pattern p6 = Pattern.compile("\\d+");
Matcher m13 = p6.matcher("abc1234efg");
System.out.println(m13.find());// 返回true，表示能匹配到数字
System.out.println(m13.start());// 返回3，因为匹配到的子字符串"1234"中的第一个字符"1"在字符串"abc1234efg"中的下标是3
System.out.println(m13.end());// 返回7，因为匹配到的子字符串"1234"中的最后一个字符"4"在字符串"abc1234efg"中之后的一个字符的下标是7
System.out.println(m13.group());// 返回"1234"
Pattern p7 = Pattern.compile("\\d+");
Matcher m14 = p7.matcher("1234efg");
System.out.println(m14.lookingAt());// 返回true，能从字符串开头匹配到数字
System.out.println(m14.start());// 返回0，由于lookingAt()只能匹配前面的字符串，所以当使用lookingAt()匹配时，start()方法总是返回0
System.out.println(m14.end());// 返回4，因为匹配到的子字符串"1234"中的最后一个字符"4"在字符串"1234efg"中的之后的一个字符的下标是4
System.out.println(m14.group());// 返回"1234"
Pattern p8 = Pattern.compile("\\d+");
Matcher m15 = p8.matcher("123456789");
System.out.println(m15.matches());// 返回true，因为能完整匹配成功
System.out.println(m15.start());// 返回0，因为要完整匹配，所以必须从第一个字符开始匹配
System.out.println(m15.end());// 返回9，即字符串的长度，因为要完整匹配，所以必须以最后一个字符结束匹配
System.out.println(m15.group());// 返回"123456789"，完整匹配的结果
// Matcher.start(int group)方法返回指定分组中匹配到的子字符串在字符串中的索引位置
// Matcher.end(int group)方法返回指定分组中匹配到的子字符串的最后一个字符在字符串中的索引位置
// Matcher.group(int group)方法返回指定分组中匹配到的子字符串
// Matcher.groupCount()方法返回有多少个分组，一个小括号是一个分组
Pattern p9 = Pattern.compile("(\\d+)([a-z]+)");
Matcher m16 = p9.matcher("123abc456efg");
System.out.println(m16.find());// 返回true，表示能匹配成功
System.out.println(m16.groupCount());// 返回2，有2个分组
System.out.println(m16.start(1));// 返回0，返回第一组匹配到的子字符串"123"在字符串中的索引号
System.out.println(m16.start(2));// 返回3，返回第二组匹配到的字符串"abc"在字符串中的索引号
System.out.println(m16.end(1));// 返回3，返回第一组匹配到的子字符串"123"的最后一个字符在字符串中的索引位置
System.out.println(m16.end(2));// 返回6，返回第二组匹配到的子字符串"abc"的最后一个字符在字符串中的索引位置
System.out.println(m16.group(1));// 返回"123"，返回第一组匹配到的子字符串
System.out.println(m16.group(2));// 返回"abc"，返回第二组匹配到的子字符串
// replaceFirst(String replacement)方法替换首次匹配的字符串片段，返回替换完成的字符串
// replaceAll(String replacement)方法替换所有匹配的字符串子串，返回替换完成的字符串
Pattern p11 = Pattern.compile("\\d+");
Matcher m18 = p11.matcher("123abc456efg");
System.out.println(m18.replaceFirst("xxx"));// 返回"xxxabc456efg"，替换首次匹配的字符串片段
System.out.println(m18.replaceAll("xxx"));// 返回"xxxabcxxxefg"，替换所有匹配的字符串
// 循环遍历所有匹配结果
Pattern p10 = Pattern.compile("\\d+");
Matcher m17 = p10.matcher("移动: 10086 电信: 10000 移动: 10001");
while (m17.find()) {
// group=10086, start=4, end=9
// group=10000, start=14, end=19
// group=10001, start=24, end=29
System.out.println("group=" + m17.group() + ", start=" + m17.start() + ", end=" + m17.end());
}
}
}
注意：在Java中\\才表示\，需要多加一个\符号。
python中的正则表达式
概述
python中关于正则表达式的操作都在re模块中，只需要导入该模块即可使用里面的方法。
import re
常用方法
re模块中常用方法如下：
| 方法 | 描述 |
|---|---|
re.match(正则表达式, 待匹配的字符串, 标志位) | 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回None，如果匹配成功则返回一个匹配的对象。标志位用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等，其实标志位其实就是设置修饰符，如re.I就是使匹配对大小写不敏感，也就相当于i修饰符。 |
re.search(正则表达式, 待匹配的字符串, 标志位) | 扫描整个字符串并返回第一个成功的匹配。re.match() 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search() 匹配整个字符串，直到找到一个匹配。 |
re.sub(pattern, repl, string, count=0, flags=0) | 用于替换字符串中的匹配项，返回替换完成的字符串。前三个为必选参数，后两个为可选参数。其中pattern是正则表达式；repl是替换后的字符串，可为一个函数；string为待匹配的字符串；count是匹配后替换的最大次数，默认为0表示替换所有的匹配；flags为匹配模式 |
re.compile(pattern[, flags]) | 用于编译正则表达式，生成一个正则表达式对象，供 match() 和 search() 这两个函数使用。其中pattern是正则表达式；flags是可选参数表示匹配模式，比如忽略大小写，多行模式等，如re.L、re.M等。 |
re.findall(pattern, string, flags=0) | 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。注意： match 和 search 是匹配一次 findall 匹配所有。其中pattern是正则表达式；string是待匹配的字符串；flags是可选参数表示匹配模式，比如忽略大小写，多行模式等，如re.L、re.M等。 |
re.finditer(pattern, string, flags=0) | 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。其中pattern是正则表达式；string是待匹配的字符串；flags是可选参数表示匹配模式，比如忽略大小写，多行模式等，如re.L、re.M等。 |
re.split(pattern, string[, maxsplit=0, flags=0]) | 按照能够匹配的子串将字符串分割后返回列表。其中pattern是正则表达式；string是待匹配的字符串；maxsplit指定分割次数，默认为0表示不限制次数；flags是可选参数表示匹配模式，比如忽略大小写，多行模式等，如re.L、re.M等。 |
示例如下：
import re
# re.match()方法尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
pattern1 = "(\d+)"
str1 = "123abc456"
ro1 = re.match(pattern1, str1, flags=re.I)
print(ro1) # <re.Match object; span=(0, 3), match='123'>
str2 = "abc456"
ro2 = re.match(pattern1, str2, flags=re.I) # 因为字符串开头不是数字，所以不能匹配
print(ro2) # None
# re.search()扫描整个字符串并返回第一个成功的匹配
# re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search 匹配整个字符串，直到找到一个匹配。
pattern2 = "\d+"
str3 = "123abc456"
ro3 = re.search(pattern2, str3, re.I | re.M)
print(ro3) # <re.Match object; span=(0, 3), match='123'>
# re.sub()用于替换字符串中的匹配项，该方法返回替换成功的字符串
pattern3 = "\d+"
str4 = "123abc456"
ro4 = re.sub(pattern3, "xxx", str4)
print(ro4) # xxxabcxxx
# re.findall()方法用于在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
# 注意： match 和 search 是匹配一次，而findall 匹配所有。
pattern4 = "\d+"
str5 = "123abc456efg789"
ll = re.findall(pattern4, str5)
print(ll) # ['123', '456', '789']
# re.split()方法按照能够匹配的子串将字符串分割后返回列表
pattern5 = "\d+"
str6 = "123abc456efg789"
ll2 = re.split(pattern5, str6)
print(ll2) # ['', 'abc', 'efg', '']
正则表达式对象
RegexObject对象
re.compile() 返回 RegexObject 对象。可以使用sub()、match()、split()、search()、findall()、finditer()等方法。
MatchObject对象
其中match()和search()方法能获取到MatchObject对象，可以使用的方法如下：
| 方法 | 描述 |
|---|---|
start([group]) | 用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0。 |
end([group]) | 用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0。 |
span([group]) | 返回一个元组包含匹配 (开始, 结束) 的位置。即(start([group]), end([group]))。 |
group([group1, ...]) | 用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)。 |
例如：
import re
pattern = "(\d+)efg(\d+).*"
str = "123efg456hij"
print(re.match(pattern, str)) # <re.Match object; span=(0, 12), match='123efg456hij'>
print(re.search(pattern, str)) # <re.Match object; span=(0, 12), match='123efg456hij'>
mo = re.match(pattern, str)
print(mo.group()) # 123efg456hij
print(mo.start()) # 0
print(mo.end()) # 12
print(mo.span()) # (0, 12)
print(mo.group(0)) # 123efg456hij
print(mo.group(1)) # 123
print(mo.start(1)) # 0
print(mo.end(1)) # 3
print(mo.span(1)) # (0, 3)
print(mo.group(2)) # 456
print(mo.start(2)) # 6
print(mo.end(2)) # 9
print(mo.span(2)) # (6, 9)
JavaScript中正则表达式
概述
在JavaScript中正则表达式的写法不一样，不是用双引号引起来的字符串，而是这样的语法格式：
// 语法
var pattern = /正则表达式/修饰符(可选)
// 例子
var pattern = /hello/i
说明：
- 正则表达式用于检索字符串
- 修饰符是可选参数，可以的值有"i"、“m”、"g"等。
使用字符串方法
在 JavaScript 中，正则表达式常用方法如下：
| 方法 | 描述 |
|---|---|
search() | 检索与正则表达式相匹配的值。 |
match() | 找到一个或多个正则表达式的匹配。 |
replace() | 替换与正则表达式匹配的子串。 |
split() | 把字符串分割为字符串数组。 |
示例如下：
<script>
var str = "123abc456efg";
// search()方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置。
var n1 = str.search(/abc/g);
console.log(n1)// 返回3
// search()方法又可以使用字符串作为参数，而字符串参数会转换成正则表达式
var n2 = str.search("abc");
console.log(n2)// 返回3
// replace()方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串，返回替换完成的结果
var r1 = str.replace(/\d+/g, "xxx");
console.log(r1)// 返回"xxxabcxxxefg"
// replace()方法可以直接接收字符串作为参数进行替换，返回替换完成的结果
var r2 = str.replace("456", "xxx");
console.log(r2)// 返回"xxxabcxxxefg"
// split()方法用于把一个字符串分割成字符串数组
var sa1 = str.split("abc");
console.log(sa1)// 返回["123", "456efg"]
var sa2 = str.split(/\d+/g);
console.log(sa2)// 返回["", "abc", "efg"]
// match()方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。该数组的内容依赖于 regexp 是否具有全局标志 g。 如果没找到匹配结果返回 null 。
var ma1 = str.match(/\d+/g);
console.log(ma1)// 返回["123", "456"]
var ma2 = str.match(/d+/);
console.log(ma2)// 返回null
</script>
使用RegExp对象
在 JavaScript 中，RegExp 对象是一个预定义了属性和方法的正则表达式对象。 使用RegExp对象的语法如下：
// 语法
var pattern = new RegExp(正则表达式, 修饰符);
或更简单的方式
var pattern = /正则表达式/修饰符;
// 示例
var pattern = new RegExp("\\d+");
var pattern = /\d+/g
注意：当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 \）。
其中RegExp对象的常用方法如下：
| 方法 | 描述 |
|---|---|
compile() | 在 1.5 版本中已废弃。 用于在脚本执行过程中编译正则表达式。 |
exec() | 检索字符串中指定的值。如果字符串中有匹配的值返回该匹配值，否则返回 null。 |
test() | 检索字符串中指定的值。返回 true 或 false。 |
toString() | 返回正则表达式的字符串。 |
例如：
<script>
// exec()方法用于检索字符串中的正则表达式的匹配。如果字符串中有匹配的值返回该匹配值，否则返回null。
var str = "123abc456efg";
var regexp1 = /\d+/g;
var r1 = regexp1.exec(str);
console.log(r1)// 返回[ "123" ]
var regexp2 = /hhh/g;
var r2 = regexp2.exec(str);
console.log(r2)// 返回null
// test()方法用于检测一个字符串是否匹配某个模式。如果字符串中有匹配的值返回true，否则返回false。
var str = "AbC123hello456";
var regexp3 = /abc/i;
var r3 = regexp3.test(str);
console.log(r3)// 返回true
var regexp4 = /worrld/g;
var r4 = regexp4.test(str);
console.log(r4)// 返回false
// toString() 方法返回正则表达式的字符串值。
var regexp4 = new RegExp("abc+", "g");
console.log(regexp4.toString())// 返回"/abc+/g"
</script>
实例：判断字符串是否全部为数字。
<script>
/**
* 判断一个字符串是否全部为数字
* @param str 待校验的字符串
* @returns {boolean} 如果字符串全部由数字组成则返回true，否则返回false
*/
function isNumber(str) {
var regexp = /^\d+$/g;
return regexp.test(str);
}
console.log(isNumber("abcefg"))// false
console.log(isNumber("123456789"))// true
console.log(isNumber("abc123efg"))// false
console.log(isNumber("123abc456"))// false
</script>
8394
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
