正则表达式学习笔记

Posted 2021-12-07 二木成林

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了正则表达式学习笔记相关的知识，希望对你有一定的参考价值。

正则表达式概述

简介

正则表达式是一种通用的知识技能，学会后，无论是前端还是后端、无论是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());以上是关于正则表达式学习笔记的主要内容，如果未能解决你的问题，请参考以下文章 
 javascript学习笔记-正则表达式-少写1000行代码的正则表达式
 正则表达式学习笔记
 JavaSE 学习笔记之正则表达式（二十五）
 Java基础学习笔记十三  常用API之正则表达式DateDateFormatCalendar
 正则表达式学习笔记
 python学习笔记9：正则表达式