Java 正则表达式
表达式意义：
1.字符
x 字符 x。例如a表示字符a
\\ 反斜线字符。在书写时要写为\\\\。（注意：因为java在第一次解析时,把\\\\解析成正则表达式\\，在第二次解析时再解析为\，所以凡是不是1.1列举到的转义字符，包括1.1的\\,而又带有\的都要写两次）
\0n 带有八进制值 0的字符 n (0 <= n <= 7)
\0nn 带有八进制值 0的字符 nn (0 <= n <= 7)
\0mnn 带有八进制值 0的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 带有十六进制值 0x的字符 hh
\uhhhh 带有十六进制值 0x的字符 hhhh
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符('\u000D')
\f 换页符 ('\u000C')
\a 报警 (bell) 符('\u0007')
\e 转义符 ('\u001B')
\c x 对应于 x 的控制符
2.字符类
[abc] a、b或 c（简单类）。例如[egd]表示包含有字符e、g或d。
[^abc] 任何字符，除了 a、b或 c（否定）。例如[^egd]表示不包含字符e、g或d。
[a-zA-Z] a到 z或 A到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a到 d或m到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e或 f（交集）
[a-z&&[^bc]] a到 z，除了 b和 c：[ad-z]（减去）
[a-z&&[^m-p]] a到 z，而非m到 p：[a-lq-z]（减去）
3.预定义字符类(注意反斜杠要写两次，例如\d写为\\d)任何字符
（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
4.POSIX 字符类（仅 U S-ASCII)(注意反斜杠要写两次，例如\p{Lower}写为\\p{Lower})
\p{Lower} 小写字母字符：[a-z]。
\p{U pper} 大写字母字符：[A-Z]
\p{A SCII} 所有 A SCII：[\x00-\x7F]
\p{A lpha} 字母字符：[\p{Lower}\p{U pper}]
\p{Digit} 十进制数字：[0-9]
\p{A lnum} 字母数字字符：[\p{A lpha}\p{Digit}]
\p{P unc t} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} 可见字符：[\p{A lnum}\p{Punc t}]
\p{P rint} 可打印字符：[\p{Graph}\x20]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{XDigit} 十六进制数字：[0-9a-f A-F]
\p{Space} 空白字符：[ \t\n\x0B\f\r]
https://www.doczj.com/doc/8f12937172.html,ng.Character 类（简单的 java 字符类型）
\p{javaLowerCas e} 等效于 https://www.doczj.com/doc/8f12937172.html,ng.C harac ter.isLowerCase()
\p{javaU pperCas e} 等效于 https://www.doczj.com/doc/8f12937172.html,ng.C haracter.isUpperCase()
\p{javaWhites pac e} 等效于 https://www.doczj.com/doc/8f12937172.html,ng.C harac ter.is Whites pac e()
\p{javaMirrored} 等效于 https://www.doczj.com/doc/8f12937172.html,ng.C haracter.isMirrored()
6.Unicode 块和类别的类
\p{I nGreek} Greek 块（简单块）中的字符
\p{Lu} 大写字母（简单类别）
\p{Sc} 货币符号
\P{I nGreek} 所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]] 所有字母，大写字母除外（减去）
7.边界匹配器
^ 行的开头，请在正则表达式的开始处使用^。例如：^(abc)表示以abc开头的字符串。注意编译的时候要设置参数M ULTILINE，如 P attern p = P https://www.doczj.com/doc/8f12937172.html,pile(regex,Pattern.MULTILINE);
$行的结尾，请在正则表达式的结束处使用。例如：(^bc a).*(abc$)表示以bc a开头以abc结尾的行。
\b 单词边界。例如\b(abc)表示单词的开始或结束包含有abc,（abc jj、jjabc都可以匹配）
\B 非单词边界。例如\B(abc)表示单词的中间包含有abc,(jjabc jj匹配而jjabc、abc jj不匹配)
\A输入的开头
\G 上一个匹配的结尾(个人感觉这个参数没什么用)。例如\\Gdog表示在上一个匹配结尾处查找dog如果没有的话则从开头查找,注意如果开头不是dog则不能匹配。
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
行结束符是一个或两个字符的序列，标记输入字符序列的行结尾。
以下代码被识别为行结束符：
‐新行（换行）符('\n')、
‐后面紧跟新行符的回车符 ("\r\n")、
‐单独的回车符 ('\r')、
‐下一行字符 ('\u0085')、
‐行分隔符('\u2028') 或
‐段落分隔符 ('\u2029)。
\z 输入的结尾
当编译模式时，可以设置一个或多个标志，例如
Pattern pattern = P attern.c ompile(patternString,P attern.CASE_INSEN SITIVE + P attern.UNICODE_CASE);
下面六个标志都是支持的：
‐CASE_IN SENSITIVE：匹配字符时与大小写无关，该标志默认只考虑U S A SCII字符。
‐UNICODE_CASE：当与CASE_INSENSITIVE结合时，使用U nic ode字母匹配
‐MULTILINE：^和$匹配一行的开始和结尾，而不是整个输入
‐UNIX_LINES：当在多行模式下匹配^和$时，只将'\n'看作行终止符
‐DOTALL: 当使用此标志时，.符号匹配包括行终止符在内的所有字符
‐CANON_EQ: 考虑U nic ode字符的规范等价
8.Greedy数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n次
X{n,m} X，至少 n次，但是不超过 m次
9.Reluctant 数量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n 次
X{n,}? X，至少 n次
X{n,m}? X，至少 n次，但是不超过 m次
10.Possessive 数量词
X?+ X，一次或一次也没有
X*+ X，零次或多次
X++ X，一次或多次
X{n}+ X，恰好 n次
X{n,}+ X，至少 n 次
X{n,m}+ X，至少 n 次，但是不超过m 次
Greedy，Reluctant，P ossess ive的区别在于:(注意仅限于进行.等模糊处理时)
greedy量词被看作“贪婪的”，因为它第一次就读入整个被模糊匹配的字符串。如果第一个匹配尝试（整个输入字符串）失败，匹配器就会在被匹配字符串中的最后一位后退一个字符并且再次尝试，重复这个过程，直到找到匹配或者没有更多剩下的字符可以后退为止。根据表达式中使用的量词，它最后试图匹配的内容是1个或者0个字符。
但是，reluc tant量词采取相反的方式：它们从被匹配字符串的开头开始，然后逐步地一次读取一个字符搜索匹配。它们最后试图匹配的内容是整个输入字符串。
最后，poss essive量词总是读完整个输入字符串，尝试一次（而且只有一次）匹配。和greedy量词不同，poss essive从不后退。11.Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组。例如(abc)表示把abc作为一个整体进行捕获
12.Back 引用
\n 任何匹配的 nth捕获组
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：
1 ((A)(B(C)))
2 \A
3 (B(C))
4 (C)
在表达式中可以通过\n来对相应的组进行引用，例如(ab)34\1就表示ab34ab，(ab)34(cd)\1\2就表示ab34c dabc d。
13.引用
\ N othing，但是引用以下字符
\Q N othing，但是引用所有字符，直到\E。QE之间的字符串会原封不动的使用(1.1中转义字符的除外)。例如, ab\\Q{|}\\\\E 可以匹配ab{|}\\
\E N othing，但是结束从 \Q开始的引用
14.特殊构造（非捕获）
(?:X) X，作为非捕获组
(?idms ux-idms ux) N othing，但是将匹配标志由 on 转为 off。比如：表达式 (?i)abc(?-i)def 这时，(?i) 打开不区分大小写开关，abc匹配
idms ux说明如下：
‐i CASE_IN SENSITIVE :U S-ASCII字符集不区分大小写。(?i)
‐d UNI X_LINES : 打开U NI X换行符
‐m MU LTILINE :多行模式(?m)
UNIX下换行为\n
WINDO WS下换行为\r\n(?s)
‐u UNICODE_CASE : U nic ode 不区分大小写。(?u)
‐x COMMENTS :可以在pattern里面使用注解，忽略pattern里面的whites pace，以及"#"一直到结尾（#后面为注解）。(?x)例如(?x)abc#as f s dads a可以匹配字符串abc
(?idms ux-idms ux:X) X，作为带有给定标志 on - off 的非捕获组。与上面的类似，上面的表达式，可以改写成为：(?i:abc)def，或者(?i)abc(?-i:def)
(?=X) X，通过零宽度的正 lookahead。零宽度正先行断言，仅当子表达式 X 在此位置的右侧匹配时才继续匹配。例如，\w+(?=\d) 表示字母后面跟数字，但不捕获数字（不回溯）
(?!X) X，通过零宽度的负 lookahead。零宽度负先行断言。仅当子表达式 X 不在此位置的右侧匹配时才继续匹配。例如，\w+(?!\d)表示字母后面不跟数字，且不捕获数字。
(?<=X) X，通过零宽度的正 lookbehind。零宽度正后发断言。仅当子表达式 X 在此位置的左侧匹配时才继续匹配。例如，
(?<=19)99表示99前面是数字19，但不捕获前面的19。（不回溯）
(? (?>X) X，作为独立的非捕获组（不回溯）
(?=X)与(?>X)的区别在于(?>X)是不回溯的。例如被匹配的字符串为abc m
当表达式为a(?:b|bc)m是可以匹配的，而当表达式是a(?>b|bc)时是不能匹配的，因为当后者匹配到b时，由于已经匹配，就跳出了非捕获组，而不再次对组内的字符进行匹配。可以加快速度。
注意：有评论说最后一句说的有问题——“这里有问题！abc m也可被a(?>b|bc)匹配！”
引言
正则表达式（regular expression）就是用一个“字符串”来描述一个特征，然后去验证另一个“字符串”是否符合这个特征。比如表达式“ab+” 描述的特征是“一个 'a' 和任意个'b' ”，那么 'ab', 'abb', 'abbbbbbbbbb' 都符合这个特征。
正则表达式可以用来：（1）验证字符串是否符合指定特征，比如验证是否是合法的邮件地址。（2）用来查找字符串，从一个长的文本中查找符合指定特征的字符串，比查找固定字符串更加灵活方便。（3）用来替换，比普通的替换更强大。
正则表达式学习起来其实是很简单的，不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂，一方面是因为大多数的文档没有做到由浅入深地讲解，概念上没有注意先后顺序，给读者的理解带来困难；另一方面，各种引擎自带的文档一般都要介绍它特有的功能，然而这部分特有的功能并不是我们首先要理解的。
文章中的每一个举例，都可以点击进入到测试页面进行测试。闲话少说，开始。
1. 正则表达式规则
1.1 普通字符
字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是"普通字符"。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。
举例1：表达式 "c"，在匹配字符串 "abc de" 时，匹配结果是：成功；匹配到的内容是："c"；匹配到的位置是：开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同）
举例2：表达式 "bc d"，在匹配字符串 "abc de" 时，匹配结果是：成功；匹配到的内容是："bcd"；匹配到的位置是：开始于1，结束于4。
1.2 简单的转义字符
一些不便书写的字符，采用在前面加 "\" 的方法。这些字符其实我们都已经熟知了。
表达式可匹配
\r, \n 代表回车和换行符
\t 制表符
\\ 代表 "\" 本身
还有其他一些在后边章节中有特殊用处的标点符号，在前面加 "\" 后，就代表该符号本身。比如：^, $都有特殊意义，如果要想匹配字符串中 "^" 和 "$" 字符，则表达式就需要写成 "\^" 和 "\$"。
表达式可匹配
\^ 匹配 ^ 符号本身
\$ 匹配 $ 符号本身
\. 匹配小数点（.）本身
这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。
举例1：表达式 "\$d"，在匹配字符串 "abc$de" 时，匹配结果是：成功；匹配到的内容是："$d"；匹配到的位置是：开始于3，结束于5。
1.3 能够与 '多种字符' 匹配的表达式
正则表达式中的一些表示方法，可以匹配 '多种字符' 其中的任意一个字符。比如，表达式 "\d" 可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。
表达式可匹配
\d 任意一个数字，0~9 中的任意一个
\w 任意一个字母或数字或下划线，也就是 A~Z,a~z,0~9,_ 中任意一个
\s 包括空格、制表符、换页符等空白字符的其中任意一个
. 小数点可以匹配除了换行符（\n）以外的任意一个字符
举例1：表达式 "\d\d"，在匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："12"；匹配到的位置是：开始于3，结束于5。
举例2：表达式 "a.\d"，在匹配 "aaa100" 时，匹配的结果是：成功；匹配到的内容是："aa1"；匹配到的位置是：开始于1，结束于4。
1.4 自定义能够匹配 '多种字符' 的表达式
使用方括号 [ ] 包含一系列字符，能够匹配其中任意一个字符。用[^ ] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。
表达式可匹配
[ab5@] 匹配 "a" 或 "b" 或 "5" 或 "@"
[^abc] 匹配 "a","b","c" 之外的任意一个字符
[f-k] 匹配 "f"~"k" 之间的任意一个字母
[^A-F0-3] 匹配 "A"~"F","0"~"3" 之外的任意一个字符
举例1：表达式 "[bc d][bc d]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："bc"；匹配到的位置是：开始于1，结束于3。
举例2：表达式 "[^abc]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："1"；匹配到的位置是：开始于3，结束于4。
1.5 修饰匹配次数的特殊符号
前面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配。
使用方法是："次数修饰"放在"被修饰的表达式"后边。比如："[bc d][bc d]" 可以写成 "[bc d]{2}"。
表达式作用
{n} 表达式重复n次，比如："\w{2}" 相当于 "\w\w"；"a{5}" 相当于 "aaaaa"
{m,n} 表达式至少重复m次，最多重复n次，比如："ba{1,3}"可以匹配 "ba"或"baa"或"baaa"
{m,} 表达式至少重复m次，比如："\w\d{2,}"可以匹配 "a12","_456","M12344"...
? 匹配表达式0次或者1次，相当于 {0,1}，比如："a[cd]?"可以匹配 "a","ac","ad"
+ 表达式至少出现1次，相当于 {1,}，比如："a+b"可以匹配 "ab","aab","aaab"...
* 表达式不出现或出现任意次，相当于 {0,}，比如："\^*b"可以匹配 "b","^^^b"...
举例1：表达式 "\d+\.?\d*" 在匹配 "I t c os ts$12.5" 时，匹配的结果是：成功；匹配到的内容是："12.5"；匹配到的位置是：开始于10，结束于14。
举例2：表达式 "go{2,8}gle" 在匹配 "A ds by goooooogle" 时，匹配的结果是：成功；匹配到的内容是："goooooogle"；匹配到的位置是：开始于7，结束于17。
1.6 其他一些代表抽象意义的特殊符号
一些符号在表达式中代表抽象的特殊意义：
表达式作用
^ 与字符串开始的地方匹配，不匹配任何字符
$ 与字符串结束的地方匹配，不匹配任何字符
\b 匹配一个单词边界，也就是单词和空格之间的位置，不匹配任何字符
进一步的文字说明仍然比较抽象，因此，举例帮助大家理解。
举例1：表达式 "^aaa" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "^" 要求与字符串开始的地方匹配，因此，只有当"aaa" 位于字符串的开头的时候，"^aaa" 才能匹配，比如："aaa xxx xxx"。
举例2：表达式 "aaa$" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "$" 要求与字符串结束的地方匹配，因此，只有当 "aaa" 位于字符串的结尾的时候，"aaa$" 才能匹配，比如："xxx xxx aaa"。
举例3：表达式 ".\b." 在匹配 "@@@abc" 时，匹配结果是：成功；匹配到的内容是："@a"；匹配到的位置是：开始于2，结束于4。
进一步说明："\b" 与 "^" 和 "$" 类似，本身不匹配任何字符，但是它要求它在匹配结果中所处位置的左右两边，其中一边是 "\w" 范围，另一边是非"\w" 的范围。
举例4：表达式 "\bend\b" 在匹配 "weekend,endfor,end" 时，匹配结果是：成功；匹配到的内容是："end"；匹配到的位置是：开始于15，结束于18。
一些符号可以影响表达式内部的子表达式之间的关系：
表达式作用
| 左右两边表达式之间 "或" 关系，匹配左边或者右边
(1). 在被修饰匹配次数的时候，括号中的表达式可以作为整体被修饰
( )
(2). 取匹配结果的时候，括号中的表达式匹配到的内容可以被单独得到
举例5：表达式 "T om|Jack" 在匹配字符串 "I'm T om, he is Jack" 时，匹配结果是：成功；匹配到的内容是："T om"；匹配到的位置是：开始于4，结束于7。匹配下一个时，匹配结果是：成功；匹配到的内容是："Jack"；匹配到的位置时：开始于15，结束于19。
举例6：表达式 "(go\s*)+" 在匹配 "Let's go go go!" 时，匹配结果是：成功；匹配到内容是："go go go"；匹配到的位置是：开始于6，结束于14。
举例7：表达式 "￥(\d+\.?\d*)" 在匹配 "＄10.9,￥20.5" 时，匹配的结果是：成功；匹配到的内容是："￥20.5"；匹配到的位置是：开始于6，结束于10。单独获取括号范围匹配到的内容是："20.5"。
2. 正则表达式中的一些高级规则
2.1 匹配次数中的贪婪与非贪婪
在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如："{m,n}", "{m,}", "?", "*", "+"，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本"dxxxdxxxd"，举例如下：
表达式匹配结果
(d)(\w+)"\w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd"
"\w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "\w+" 也能够匹配上最后一个(d)(\w+)(d)
"d"，但是为了使整个表达式匹配成功，"\w+" 可以 "让出" 它本来能够匹配的最后一个 "d"
由此可见，"\w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这种匹配原则就叫作 "贪婪" 模式。
非贪婪模式：
在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式，也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本 "dxxxdxxxd" 举例：
表达式匹配结果
(d)(\w+?)"\w+?" 将尽可能少的匹配第一个 "d" 之后的字符，结果是："\w+?" 只匹配了一个 "x"
为了让整个表达式匹配成功，"\w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配，从而使整个表达式匹配成功。
(d)(\w+?)(d)
因此，结果是："\w+?" 匹配 "xxx"
更多的情况，举例如下：
举例1：表达式 "
aa
bb
aa
bb
举例2：相比之下，表达式 "
aa
bb
2.2 反向引用 \1, \2...
表达式在匹配时，表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串可以单独获取。这一点，在前面的举例中，已经多次展示了。在实际应用场合中，当用某种边界来查找，而所要获取的内容又不包含边界时，必须使用小括号来指定所要的范围。比如前面的 "
其实，"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\1" 引用第1对括号内匹配到的字符串，"\2" 引用第2对括号内匹配到的字符串……以此类推，如果一对括号内包含另一对括号，则外层的括号先排序号。换句话说，哪一对的左括号"(" 在前，那这一对就先排序号。
举例如下：
举例1：表达式 "('|")(.*?)(\1)" 在匹配 " 'H ello', "World" " 时，匹配结果是：成功；匹配到的内容是：" 'H ello' "。再次匹配下一个时，可以匹配到 " "World" "。
举例2：表达式 "(\w)\1{4,}" 在匹配 "aa bbbb abcdefg ccccc111121111 999999999" 时，匹配结果是：成功；匹配到的内容是 "ccccc"。再次匹配下一个时，将得到 999999999。这个表达式要求 "\w" 范围的字符至少重复5次，注意与 "\w{5,}" 之间的区别。
举例3：表达式 "<(\w+)\s*(\w+(=('|").*?\4)?\s*)*>.*?" 在匹配 "
2.3 预搜索，不匹配；反向预搜索，不匹配
前面的章节中，我讲到了几个代表抽象意义的特殊符号："^"，"$"，"\b"。它们都有一个共同点，那就是：它们本身不匹配任何字符，只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件。理解到这个概念以后，本节将继续介绍另外一种对 "两头" 或者"缝隙" 附加条件的，更加灵活的表示方法。
正向预搜索："(?=xxxxx)"，"(?!xxxxx)"
格式："(?=xxxxx)"，在被匹配的字符串中，它对所处的 "缝隙" 或者 "两头" 附加的条件是：所在缝隙的右侧，必须能够匹配上xxxxx 这部分的表达式。因为它只是在此作为这个缝隙上附加的条件，所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "\b"，本身不匹配任何字符。"\b" 只是将所在缝隙之前、之后的字符取来进行了一下判断，不会影响后边的表达式来真正的匹配。
举例1：表达式 "Windows(?=NT|XP)" 在匹配 "Windows98, Window s NT, Windows2000" 时，将只匹配 "Windows NT" 中的 "Windows "，其他的 "Windows" 字样则不被匹配。
举例2：表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时，将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。
格式："(?!xxxxx)"，所在缝隙的右侧，必须不能匹配 xxxxx 这部分表达式。
举例3：表达式 "((?!\bstop\b).)+" 在匹配 "fdjka ljfdl s top fjdsla fdj" 时，将从头一直匹配到 "s top" 之前的位置，如果字符串中没有 "s top"，则匹配整个字符串。
举例4：表达式 "do(?!\w)" 在匹配字符串 "done, do, dog" 时，只能匹配 "do"。在本条举例中，"do" 后边使用 "(?!\w)" 和使用 "\b" 效果是一样的。
反向预搜索："(?<=xxxxx)"，"(?
这两种格式的概念和正向预搜索是类似的，反向预搜索要求的条件是：所在缝隙的 "左侧"，两种格式分别要求必须能够匹配和必须不能够匹配指定表达式，而不是去判断右侧。与 "正向预搜索" 一样的是：它们都是对所在缝隙的一种附加条件，本身都不匹配任何字符。
举例5：表达式 "(?<=\d{4})\d+(?=\d{4})" 在匹配 "1234567890123456" 时，将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JSc ript.RegE xp 不支持反向预搜索，因此，本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索，比如：Java 1.4以上的 java.util.regex 包，.NET中Sys tem.Text.RegularExpressions命名空间，以及本站推荐的最简单易用的 DEELX 正则引擎。
3. 其他通用规则
还有一些在各个正则表达式引擎之间比较通用的规则，在前面的讲解过程中没有提到。
3.1表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）
形式字符范围
\xXX 编号在 0 ~ 255 范围的字符，比如：空格可以使用 "\x20" 表示
\uXXXX 任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，比如："\u4E2D"
3.2在表达式 "\s"，"\d"，"\w"，"\b" 表示特殊意义的同时，对应的大写字母表示相反的意义
表达式可匹配
\S 匹配所有非空白字符（"\s" 可匹配各个空白字符）
\D 匹配所有的非数字字符
\W 匹配所有的字母、数字、下划线以外的字符
\B 匹配非单词边界，即左右两边都是 "\w" 范围或者左右两边都不是 "\w" 范围时的字符缝隙
3.3在表达式中有特殊意义，需要添加 "\" 才能匹配该字符本身的字符汇总
字符说明
^ 匹配输入字符串的开始位置。要匹配 "^" 字符本身，请使用 "\^"
$ 匹配输入字符串的结尾位置。要匹配 "$" 字符本身，请使用 "\$"
( ) 标记一个子表达式的开始和结束位置。要匹配小括号，请使用 "\(" 和 "\)"
[ ] 用来自定义能够匹配 '多种字符' 的表达式。要匹配中括号，请使用 "\[" 和 "\]"
{ } 修饰匹配次数的符号。要匹配大括号，请使用 "\{" 和 "\}"
. 匹配除了换行符（\n）以外的任意一个字符。要匹配小数点本身，请使用 "\."
? 修饰匹配次数为 0 次或 1 次。要匹配 "?" 字符本身，请使用 "\?"
+ 修饰匹配次数为至少 1 次。要匹配 "+" 字符本身，请使用 "\+"
* 修饰匹配次数为 0 次或任意次。要匹配 "*" 字符本身，请使用 "\*"
| 左右两边表达式之间 "或" 关系。匹配 "|" 本身，请使用 "\|"
3.4括号 "( )" 内的子表达式，如果希望匹配结果不进行记录供以后使用，可以使用 "(?:xxxxx)" 格式
举例1：表达式 "(?:(\w)\1)+" 匹配 "a bbcc dd efg" 时，结果是 "bbcc dd"。括号 "(?:)" 范围的匹配结果不进行记录，因此"(\w)" 使用 "\1" 来引用。
3.5常用的表达式属性设置简介：I gnorec ase，Singleline，M ultiline，Global
表达式属性说明
Ignorecase
默认情况下，表达式中的字母是要区分大小写的。配置为 Ignorecase 可使匹配时不区分大小写。有的表达式引擎，
把 "大小写" 概念延伸至 UNICODE 范围的大小写。
Singleline
默认情况下，小数点 "." 匹配除了换行符（\n）以外的字符。配置为 Singleline 可使小数点可匹配包括换行符在
内的所有字符。
Multiline 默认情况下，表达式 "^" 和 "$" 只匹配字符串的开始① 和结尾④ 位置。如：
①xxxxxxxxx②\n
③xxxxxxxxx④
配置为 Multiline 可以使 "^" 匹配① 外，还可以匹配换行符之后，下一行开始前③ 的位置，使 "$" 匹配④ 外，还可以匹配换行符之前，一行结束② 的位置。
Global 主要在将表达式用来替换时起作用，配置为 Global 表示替换所有的匹配。
4. 其他提示
4.1如果想要了解高级的正则引擎还支持那些复杂的正则语法，可参见本站 DEELX 正则引擎的说明文档。
4.2如果要要求表达式所匹配的内容是整个字符串，而不是从字符串中找一部分，那么可以在表达式的首尾使用 "^" 和 "$"，比如："^\d+$" 要求整个字符串只有数字。
4.3如果要求匹配的内容是一个完整的单词，而不会是单词的一部分，那么在表达式首尾使用 "\b"，比如：使用
"\b(if|while|els e|void|int……)\b" 来匹配程序中的关键字。
4.4表达式不要匹配空字符串。否则会一直得到匹配成功，而结果什么都没有匹配到。比如：准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时，整数、小数点、小数数字都可以省略，但是不要将表达式写成："\d*\.?\d*"，因为如果什么都没有，这个表达式也可以匹配成功。更好的写法是："\d+\.?\d*|\.\d+"。
4.5能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0次，而这个括号整体又可以匹配无限次，那么情况可能比上一条所说的更严重，匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了，比如 .N ET的正则表达式，但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环，也可以从这一点入手，查找一下是否是本条所说的原因。
4.6合理选择贪婪模式与非贪婪模式，参见话题讨论。
4.7或 "|" 的左右两边，对某个字符最好只有一边可以匹配，这样，不会因为 "|" 两边的表达式因为交换位置而有所不同。
5. 进阶与实战
有了从本文中掌握的基础，我们可以从实践中进一步巩固我们使用正则表达式的技巧。
5.1下载正则表达式文档 c hm 版本
[点击下载 c hm 版本] - DEE LX 正则语法，包含其他高级语法的 c hm 版本。
5.2下载正则工具 Regex Matc h T rac er 2.0试用版（正版很值得购买）
[下载 M atc h T racer] - 471kb
5.3免费使用 Regex M atc h T racer Web 版
[使用 M atc h T racer Web 版]
本 Web 版工具为免费使用，不受 Regex M atch T racer 主程序的试用期限制。
5.4更多深入话题及使用案例
[关于递归匹配的讨论] - 讨论如何使用不支持递归的正则引擎匹配嵌套结构
[有问题与站长交流] - 与站长交流和讨论
[本页脚本] - 本页的“关闭高亮”功能，采用 javasc ript 的正则表达式实现的。
比如表达式：(a+b|[cd])$
如果你曾经用过P erl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉
这个术语，那么“正则表达式”（Regular E xpression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。
许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。
然而，如果现在就需要使用正则表达式，又该怎么办呢？你可以从https://www.doczj.com/doc/8f12937172.html,下载源代码开放的Jakarta-ORO库。本文接下来的内容先简要地介绍正则表达式的入门知识，然后以Jakarta-ORO API为例介绍如何使用正则表达式。
一、正则表达式基础知识
我们先从简单的开始。假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。如果搜索对大小写不敏感，单词“catalog”、“Catherine”、“sophisticated”都可以匹配。也就是说：
1.1 句点符号
假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配
“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：
1.2 方括号符号
为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：
1.3 “或”符号
如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。“|”操作符的基本意义就是“或”运算。要匹配“toon”，使用
“t(a|e|i|o|oo)n”正则表达式。这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”。圆括号还可以用来分组，具体请参见后面介绍。
1.4 表示匹配次数的符号
表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：
假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“\”。
图一：匹配所有123-12-1234形式的社会安全号码
假设进行搜索的时候，你希望连字符号可以出现，也可以不出现——即，999-99-9999和999999999都属于正确的格式。这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：
图二：匹配所有123-12-1234和123121234形式的社会安全号码
下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它
的正则表达式前面是数字部分“[0-9]{4}”，再加上字母部分“[A-Z]{2}”。图三显示了完整的正则表达式。
图三：匹配典型的美国汽车牌照号码，如8836KV
1.5 “否”符号
“^”符号称为“否”符号。如果用在方括号内，“^”表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。
图四：匹配所有单词，但“X”开头的除外
1.6 圆括号和空白符号
假设要从格式为“June 26, 1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：
图五：匹配所有Moth DD,YYYY格式的日期
新出现的“\s”符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：
图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组
1.7 其它符号
为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：
表二：常用符号
例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“\d”。修改后的正则表达式如图七所示：
图七：匹配所有123-12-1234格式的社会安全号码
二、Jakarta-ORO库
有许多源代码开放的正则表达式库可供Java程序员使用，而且它们中的许多支持Perl 5兼容的正则表达式语法。我在这里选用的是Jakarta-ORO正则表达式库，它是最全面的正则表达式API之一，而且它与Perl 5正则表达式完全兼容。另外，它也是优化得最好的API之一。
Jakarta-ORO库以前叫做OROMatcher，Daniel Savarese大方地把它赠送给了Jakarta Project。你可以按照本文最后参考资源的说明下载它。
我首先将简要介绍使用Jakarta-ORO库时你必须创建和访问的对象，然后介绍如何使用Jakarta-ORO API。
▲ PatternCompiler对象
首先，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。
▲ Pattern对象
要把正则表达式编译成Pattern对象，调用compiler对象的compile()方法，并在调用参数中指定正则表达式。例如，你可以按照下面这种方式编译正则表达式“t[aeio]n”：
默认情况下，编译器创建一个大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配“tin”、“tan”、“ten”和“ton”，但不匹配“Tin”和“taN”。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数：
创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。
▲ PatternMatcher对象
PatternMatcher对象根据Pattern对象和字符串进行匹配检查。你要实例化一个
Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：
使用PatternMatcher对象，你可以用多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：
· boolean matches(String input, Pattern pattern)：当输入字符串和正则表达式要精确匹配时使用。换句话说，正则表达式必须完整地描述输入字符串。
· boolean matc hesPrefix(String input, Pattern pattern)：当正则表达式匹配输入字符串起始部分时使用。
· boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用（即，它必须是一个子串）。
另外，在上面三个方法调用中，你还可以用PatternMatcherInput对象作为参数替代String对象；这时，你可以从字符串中最后一次匹配的位置开始继续进行匹配。当字符串可能有多个子串匹配给定的正则表达式时，用PatternMatcherInput对象作为参数就很有用了。用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：
· boolean matches(PatternMatcherInput input, Pattern pattern)
· boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)
· boolean contains(PatternMatcherI nput input, Pattern pattern)
三、应用实例
下面我们来看看Jakarta-ORO库的一些应用实例。
3.1 日志文件处理
任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。在典型的BEA WebLogic日志文件中，日志记录的格式如下：
分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。
首先我们来看看IP地址。IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。因此，IP地址中的每一个字节有至少一个、最多三个数字。图八显示了为IP地址编写的正则表达式：
图八：匹配IP地址
IP地址中的句点字符必须进行转义处理（前面加上“\”），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。句点在正则表达式中的特殊含义本文前面已经介绍。
日志记录的时间部分由一对方括号包围。你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（“[”），提取出所有不超过结束方括号字符（“]”）的内容，向前寻找直至找到结束方括号字符。图九显示了这部分的正则表达式。
图九：匹配至少一个字符，直至找到“]”
现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP地址和时间。注意，为了匹配“- -”（但不提取它），正则表达式中间加入了“\s-\s-\s”。完整的正则表达式如图十所示。
图十：匹配IP地址和时间标记
现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。
为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：
这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（“\”）进行转义处理。图十不是Java的表示形式，所以我们要在每个“\”前面加上一个“\”以免出现编译错误。遗憾的是，转义处理过程很容易出现错误，所以应该小心谨慎。你可以首先输入未经转义处理的正则表达式，然后从左到右依次把每一个“\”替换成“\\”。如果要复检，你可以试着把它输出到屏幕上。
初始化字符串之后，实例化PatternCompiler对象，用PatternCompiler编译正则表达式创建一个Pattern对象：
现在，创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：
接下来，利用PatternMatcher接口返回的MatchResult对象，输出匹配的组。由于logEntry字符串包含匹配的内容，你可以看到类如下面的输出：
3.2 HTML处理实例一
下面一个任务是分析HTML页面内FONT标记的所有属性。HTML页面内典型的FONT标记如下所示：
程序将按照如下形式，输出每一个FONT标记的属性：
在这种情况下，我建议你使用两个正则表达式。第一个如图十一所示，它从字体标记提取出“"face="Arial, Serif" size="+2" color="red"”。
图十一：匹配FONT标记的所有属性
第二个正则表达式如图十二所示，它把各个属性分割成名字-值对。
图十二：匹配单个属性，并把它分割成名字-值对
分割结果为：
JS正则表达式大全 JS正则表达式大全【1】 正则表达式中的特殊字符【留着以后查用】字符含意 \ 做为转意，即通常在"\"后面的字符不按原来意义解释，如/b/匹配字符"b"，当b前面加了反斜杆后/\b/，转意为匹配一个单词的边界。 -或- 对正则表达式功能字符的还原，如"*"匹配它前面元字符0次或多次，/a*/将匹配a,aa,aaa，加了"\"后，/a\*/将只匹配"a*"。 ^ 匹配一个输入或一行的开头，/^a/匹配"an A"，而不匹配"An a" $ 匹配一个输入或一行的结尾，/a$/匹配"An a"，而不匹配"an A" * 匹配前面元字符0次或多次，/ba*/将匹配b,ba,baa,baaa + 匹配前面元字符1次或多次，/ba*/将匹配ba,baa,baaa ? 匹配前面元字符0次或1次，/ba*/将匹配b,ba (x) 匹配x保存x在名为$1...$9的变量中 x|y 匹配x或y {n} 精确匹配n次 {n,} 匹配n次以上 {n,m} 匹配n-m次 [xyz] 字符集(character set)，匹配这个集合中的任一一个字符(或元字符) [^xyz] 不匹配这个集合中的任何一个字符 [\b] 匹配一个退格符 \b 匹配一个单词的边界 \B 匹配一个单词的非边界 \cX 这儿，X是一个控制符，/\cM/匹配Ctrl-M \d 匹配一个字数字符，/\d/ = /[0-9]/ \D 匹配一个非字数字符，/\D/ = /[^0-9]/ \n 匹配一个换行符 \r 匹配一个回车符 \s 匹配一个空白字符，包括\n,\r,\f,\t,\v等 \S 匹配一个非空白字符，等于/[^\n\f\r\t\v]/ \t 匹配一个制表符 \v 匹配一个重直制表符 \w 匹配一个可以组成单词的字符(alphanumeric，这是我的意译，含数字)，包括下划线，如[\w]匹配
本文分十四个类别对正则表达式的意义进行了解释，这十四各类别是：字符/字符类/预定义字符类/POSIX字符类/https://www.doczj.com/doc/8f12937172.html,ng.Character类/Unicode块和类别的类/边界匹配器/Greedy数量词/Reluctant数量词/Possessive数量词/Logical运算符/Back引用/引用/特殊构造。 1.1.字符 x 字符 x。例如a表示字符a \\ 反斜线字符。在书写时要写为\\\\。（注意：因为java在第一次解析时把\\\\解析成正则表达式\\，在第二次解析时再解析为\，所以凡是不是1.1列举到的转义字符，包括1.1的\\,而又带有\的都要写两次） \0n 带有八进制值 0的字符 n (0 <= n <= 7) \0nn 带有八进制值 0的字符 nn (0 <= n <= 7) \0mnn 带有八进制值 0的字符 mnn（0 <= m <= 3、0 <= n <= 7） \xhh 带有十六进制值 0x的字符 hh \uhhhh 带有十六进制值 0x的字符 hhhh \t 制表符 ('\u0009') \n 新行（换行）符 ('\u000A') \r 回车符 ('\u000D') \f 换页符 ('\u000C') \a 报警 (bell) 符 ('\u0007') \e 转义符 ('\u001B') \cx 对应于 x 的控制符 1.2.字符类 [abc] a、b或 c（简单类）。例如[egd]表示包含有字符e、g或d。 [^abc] 任何字符，除了 a、b或 c（否定）。例如[^egd]表示不包含字符e、g或d。 [a-zA-Z] a到 z或 A到 Z，两头的字母包括在内（范围） [a-d[m-p]] a到 d或 m到 p：[a-dm-p]（并集） [a-z&&[def]] d、e或 f（交集） [a-z&&[^bc]] a到 z，除了 b和 c：[ad-z]（减去） [a-z&&[^m-p]] a到 z，而非 m到 p：[a-lq-z]（减去） 1.3.预定义字符类(注意反斜杠要写两次，例如\d写为\\d) . 任何字符（与行结束符可能匹配也可能不匹配） \d 数字：[0-9] \D 非数字： [^0-9] \s 空白字符：[ \t\n\x0B\f\r] \S 非空白字符：[^\s] \w 单词字符：[a-zA-Z_0-9] \W 非单词字符：[^\w] 1.4.POSIX 字符类（仅 US-ASCII)(注意反斜杠要写两次，例如\p{Lower}写为\\p{Lower})
Sed基础用法篇 刚开始接触linux，其实还是老实用vim来编辑文件，不过同样的过程重复多次，你就要想办法简化你的过程。sed绝对是一个好的命令或者工具，你不需要用vim打开文件就可以直接编辑(推荐掌握以下用法)。 1、删除行首空格 sed 's/^[ ]*//g' filename sed 's/^ *//g' filename sed 's/^[[:space:]]*//g' filename 2、行后和行前添加新行 行后：sed 's/pattern/&\n/g' filename 行前：sed 's/pattern/\n&/g' filename &代表pattern 3、使用变量替换(使用双引号) sed ‐e "s/$var1/$var2/g" filename 4、在第一行前插入文本 sed ‐i '1 i\插入字符串' filename 5、在最后一行插入 sed ‐i '$ a\插入字符串' filename
6、在匹配行前插入 sed ‐i '/pattern/ i "插入字符串"' filename 7、在匹配行后插入 sed ‐i '/pattern/ a "插入字符串"' filename 8、删除文本中空行和空格组成的行以及#号注释的行 grep ‐v ^# filename | sed /^[[:space:]]*$/d | sed /^$/d 9、要将目录/modules下面所有文件中的zhangsan都修改成list，可用如下命令:(注意备份原文件) sed ‐i 's/zhangsan/list/g' `grep zhangsan ‐rl /modules` Linux命令FIND详解 由于find具有强大的功能，所以它的选项也很多，其中大部分选项都值得我们花时间来了解一下。即使系统中含有网络文件系统( NFS)，find命令在该文件系统中同样有效，只你具有相应的权限。在运行一个非常消耗资源的find命令时，很多人都倾向于把它放在后台执行，因为遍历一个大的文件系统可能会花费很长的时间(这里是指30G字节以上的文件系统)。 一、find 命令格式 1、find命令的一般形式为； find pathname ‐options [‐print ‐exec ‐ok ...]
正则表达式 第一部分： ----------------- 正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。 支持多种平台 正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group 组织认定。 正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。 许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML和XML，这些采纳通常只是整个标准的一个子集。 比你想象的还要普通 随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。 正则表达式101 很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。 1.简介： java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。 它包括两个类：Pattern和Matcher 。 Pattern：一个Pattern是一个正则表达式经编译后的表现模式。 Matcher：一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。 以下我们就分别来看看这两个类： 2.Pattern类: Pattern的方法如下： static Pattern compile(String regex) 将给定的正则表达式编译并赋予给Pattern类 static Pattern compile(String regex, int flags) 同上，但增加flag参数的指定，可选的flag参数包括：CASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ int flags() 返回当前Pattern的匹配flag参数. Matcher matcher(CharSequence input) 生成一个给定命名的Matcher对象 static boolean matches(String regex, CharSequence input) 编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生成一个Matcher实例。 String pattern() 返回该Patter对象所编译的正则表达式。 String[] split(CharSequence input) 将目标字符串按照Pattern里所包含的正则表达式为模进行分割。 String[] split(CharSequence input, int limit) 作用同上，增加参数limit目的在于要指定分割的段数，如将limi设为2，那么目标字符串将根据正则表达式分为割为两段。
正则表达式 一、什么是这则表达式 正则表达式（regular expressions）是一种描述字符串集的方法，它是以字符串集中各字符串的共有特征为依据的。正则表达式可以用于搜索、编辑或者是操作文本和数据。它超出了java程序设计语言的标准语法，因此有必要去学习特定的语法来构建正则表达式。一般使用的java.util.regex API所支持的正则表达式语法。 二、测试用具 import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Regex{ public static void main(String[]args)throws Exception{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); if(br==null){ System.out.println("没有输入任何数据"); System.exit(1); } while(true){ System.out.print("输入表达式："); Pattern pattern=https://www.doczj.com/doc/8f12937172.html,pile(br.readLine()); System.out.print("输入字符串："); Matcher matcher=pattern.matcher(br.readLine()); boolean found=false; while(matcher.find()){ System.out.println("找到子字符串"+matcher.group()+" 开始于索引"+matcher.start()+"结束于索引"+matcher.end()+"\n") found=true; } if(!found){ System.out.println("没有找到子字符串\n"); } } } }
正则表达式基础知识 一个正则表达式就是由普通字符（例如字符a 到z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。如：
下面看几个例子： "^The"：表示所有以"The"开始的字符串（"There"，"The cat"等）； "of despair$"：表示所以以"of despair"结尾的字符串； "^abc$"：表示开始和结尾都是"abc"的字符串——呵呵，只有"abc"自己了；"notice"：表示任何包含"notice"的字符串。 '*'，'+'和'?'这三个符号，表示一个或一序列字符重复出现的次数。它们分别表示“没有或更多”，“一次或更多”还有“没有或一次”。下面是几个例子： "ab*"：表示一个字符串有一个a后面跟着零个或若干个b。（"a", "ab", "abbb",……）；"ab+"：表示一个字符串有一个a后面跟着至少一个b或者更多； "ab?"：表示一个字符串有一个a后面跟着零个或者一个b； "a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b。 也可以使用范围，用大括号括起，用以表示重复次数的范围。 "ab{2}"：表示一个字符串有一个a跟着2个b（"abb"）； "ab{2,}"：表示一个字符串有一个a跟着至少2个b； "ab{3,5}"：表示一个字符串有一个a跟着3到5个b。
请注意，你必须指定范围的下限（如："{0,2}"而不是"{,2}"）。 还有，你可能注意到了，'*'，'+'和'?'相当于"{0,}"，"{1,}"和"{0,1}"。 还有一个'|'，表示“或”操作： "hi|hello"：表示一个字符串里有"hi"或者"hello"； "(b|cd)ef"：表示"bef"或"cdef"； "(a|b)*c"：表示一串"a""b"混合的字符串后面跟一个"c"； '.'可以替代任何字符： "a.[0-9]"：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字； "^.{3}$"：表示有任意三个字符的字符串（长度为3个字符）； 方括号表示某些字符允许在一个字符串中的某一特定位置出现： "[ab]"：表示一个字符串有一个"a"或"b"（相当于"a|b"）； "[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a|b|c|d"或者"[abcd]"）；"^[a-zA-Z]"：表示一个以字母开头的字符串； "[0-9]%"：表示一个百分号前有一位的数字； "[0-9]+"：表示一个以上的数字； ",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。 你也可以在方括号里用'^'表示不希望出现的字符，'^'应在方括号里的第一位。（如："%[^a-zA-Z]%"表 示两个百分号中不应该出现字母）。 为了逐字表达，必须在"^.$()|*+?{\"这些字符前加上转移字符'\'。 请注意在方括号中，不需要转义字符。
Java代码 1.Java中在某个字符串中查询某个字符或者某个子字串Java代码
Java代码 3.对字符串的分割 Java代码 如果用正则表达式分割就如上所示，一般我们都会使用下面更简单的方法：Java代码 4.字符串的替换/删除 Java代码 如果要把字符串中的@都给删除，只用要空字符串替换就可以了： Java代码
注：对Pattern类的说明： 1.public final class java.util.regex.Pattern是正则表达式编译后的表达法。 下面的语句将创建一个Pattern对象并赋值给句柄pat：Pattern pat = https://www.doczj.com/doc/8f12937172.html,pile(regEx); 有趣的是，Pattern类是final类，而且它的构造器是private。也许有人告诉你一些设计模式的东西，或者你自己查有关资料。这里的结论是：Pattern类不能被继承，我们不能通过new创建Pattern类的对象。 因此在Pattern类中，提供了2个重载的静态方法，其返回值是Pattern对象（的引用）。如：Java代码 1.public static Pattern compile(String regex) { 2.return new Pattern(regex, 0); 3.} 当然，我们可以声明Pattern类的句柄，如Pattern pat = null； 2.pat.matcher(str)表示以用Pattern去生成一个字符串str的匹配器，它的返回值是一个Matcher类的引用。 我们可以简单的使用如下方法：boolean rs = https://www.doczj.com/doc/8f12937172.html,pile(regEx).matcher(str).find();
Java正则表达式验证格式（邮箱、电话号码） package com.firewolf.utils;import java.util.regex.Matcher;import java.util.regex.Pattern;/** * 使用正则表达式验证输入格式* @author liuxing * */public class RegexValidateUtil { public static void main(String[] args) { System.out.println(checkEmail("14_8@qw.df")); System.out.println(checkMobileNumber("071-3534452")); } /** * 验证邮箱* @param email * @return */ public static boolean checkEmail(String email){ boolean flag = false; try{ String check = "^([a-z0-9A-Z]+[-|_|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0 -9A-Z]+)?\\.)+[a-zA-Z]{2,}$"; Pattern regex = https://www.doczj.com/doc/8f12937172.html,pile(check); Matcher matcher = regex.matcher(email); flag = matcher.matches(); }catch(Exception e){ flag = false; } return flag; } /** * 验证手机号码* @param mobiles * @return */ public static boolean checkMobileNumber(String
多少年来，许多的编程语言和工具都包含对正则表达式的支持，.NET基础类库中包含有一个名字空间和一系列可以充分发挥规则表达式威力的类，而且它们也都与未来的Perl 5中的规则表达式兼容。 此外，regexp类还能够完成一些其他的功能，例如从右至左的结合模式和表达式的编辑等。 在这篇文章中，我将简要地介绍System.Text.RegularExpression中的类和方法、一些字符串匹配和替换的例子以及组结构的详细情况，最后，还会介绍一些你可能会用到的常见的表达式。 应该掌握的基础知识 规则表达式的知识可能是不少编程人员“常学常忘”的知识之一。在这篇文章中，我们将假定你已经掌握了规则表达式的用法，尤其是Perl 5中表达式的用法。.NET的regexp类是Perl 5中表达式的一个超集，因此，从理论上说它将作为一个很好的起点。我们还假设你具有了C#的语法和.NET架构的基本知识。 如果你没有规则表达式方面的知识，我建议你从Perl 5的语法着手开始学习。在规则表达式方面的权威书籍是由杰弗里?弗雷德尔编写的《掌握表达式》一书，对于希望深刻理解表达式的读者，我们强烈建议阅读这本书。 RegularExpression组合体 regexp规则类包含在System.Text.RegularExpressions.dll文件中，在对应用软件进行编译时你必须引用这个文件，例如： csc r:System.Text.RegularExpressions.dll foo.cs 命令将创建foo.exe文件，它就引用了System.Text.RegularExpressions文件。 名字空间简介 在名字空间中仅仅包含着6个类和一个定义，它们是： Capture: 包含一次匹配的结果； CaptureCollection: Capture的序列； Group: 一次组记录的结果，由Capture继承而来； Match: 一次表达式的匹配结果，由Group继承而来； MatchCollection: Match的一个序列； MatchEvaluator: 执行替换操作时使用的代理； Regex: 编译后的表达式的实例。 Regex类中还包含一些静态的方法： Escape: 对字符串中的regex中的转义符进行转义； IsMatch: 如果表达式在字符串中匹配，该方法返回一个布尔值； Match: 返回Match的实例； Matches: 返回一系列的Match的方法； Replace: 用替换字符串替换匹配的表达式； Split: 返回一系列由表达式决定的字符串； Unescape:不对字符串中的转义字符转义。
Java中的正则表达式 众所周知，在程序开发中，难免会遇到需要匹配、查找、替换、判断字符串的情况发生，而这些情况有时又比较复杂，如果用纯编码方式解决，往往会浪费程序员的时间及精力。因此，学习及使用正则表达式，便成了解决这一矛盾的主要手段。 大家都知道，正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。 自从jdk1.4推出java.util.regex包，就为我们提供了很好的JAVA正则表达式应用平台。 因为正则表达式是一个很庞杂的体系，所以我仅例举些入门的概念，更多的请参阅相关书籍及自行摸索。 \\ 反斜杠 \t 间隔 ('\u0009') \n 换行 ('\u000A') \r 回车 ('\u000D') \d 数字等价于[0-9] \D 非数字等价于[^0-9] \s 空白符号 [\t\n\x0B\f\r] \S 非空白符号 [^\t\n\x0B\f\r] \w 单独字符 [a-zA-Z_0-9] \W 非单独字符 [^a-zA-Z_0-9] \f 换页符 \e Escape \b 一个单词的边界 \B 一个非单词的边界 \G 前一个匹配的结束 ^为限制开头 ^java 条件限制为以Java为开头字符 $为限制结尾 java$ 条件限制为以java为结尾字符 .为限制一个任意字符 java.. 条件限制为java后除换行外任意两个字符 加入特定限制条件「[]」 [a-z] 条件限制在小写a to z范围中一个字符 [A-Z] 条件限制在大写A to Z范围中一个字符 [a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符 [0-9] 条件限制在小写0 to 9范围中一个字符
要想真正的用好正则表达式，正确的理解元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。 字符描述 \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“\n”匹配字符“n”。“\\n”匹配一个换行符。序列“\\”匹配“\”而“\（”则匹配“（”。 ^ 匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。 $ 匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。 * 匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0，}。 + 匹配前面的子表达式一次或多次。例如，“z o+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1，}。 ? 匹配前面的子表达式零次或一次。例如，“do（es）?”可以匹配“does”或“does”中的“d o”。?等价于{0，1}。 {n} n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。 {n,} n是一个非负整数。至少匹配n次。例如，“o{2，}”不能匹配“Bob”中的“o”，但能匹配“fo o o ood”中的所有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”在内的任何字符，请使用像“[\s\S]”的模式。
1、正则表达式-完结篇---工具类开发--- ? 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 '/.+/', 'email'=> '/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/', 'url'=> '/^http(s?):\/\/(?:[A-za-z0-9-]+\.)+[A-za-z]{2,4}(?:[\/ \?#][\/=\?%\-&~`@[\]\':+!\.#\w]*)?$/', 'currency'=> '/^\d+(\.\d+)?$/', 'number'=> '/^\d+$/', 'zip'=> '/^\d{6}$/', 'integer'=> '/^[-\+]?\d+$/', 'double'=> '/^[-\+]?\d+(\.\d+)?$/',
5 1 6 1 7 1 8 1 9 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2'english'=> '/^[A-Za-z]+$/', 'qq'=> '/^\d{5,11}$/', 'mobile'=> '/^1(3|4|5|7|8)\d{9}$/', ); //定义其他属性 private$returnMatchResult=false; //返回类型判断 private$fixMode=null; //修正模式 private$matches=array(); //存放匹配结果 private$isMatch=false; //构造函数，实例化后传入默认的两个参数 public function __construct($returnMatchResult=false,$fixMode=null){ $this->returnMatchResult=$returnMatchResult; $this->fixMode=$fixMode; } //判断返回结果类型，为匹配结果matches还是匹配成功与否isMatch，并调用返回方法 private function regex($pattern,$subject){ if(array_key_exists(strtolower($pattern), $this->validate)) $pattern=$this->validate[$pattern].$this->fixMode; //判断后再连接上修正模式作为匹配的正则表达式 $this->returnMatchResult ?
JAVA中正则表达式使用介绍 一、什么是正则表达式 正则表达式是一种可以用于模式匹配和替换的强有力的工具。我们可以在几乎所有的基于UNIX系统的工具中找到正则表达式的身影，例如，vi编辑器，Perl或PHP脚本语言，以及awk或sed shell程序等。此外，象JavaScript这种客户端的脚本语言也提供了对正则表达式的支持。 正则表达式可以让用户通过使用一系列的特殊字符构建匹配模式，进行信息的验证。 此外，它还能够高效地创建、比较和修改字符串，以及迅速地分析大量文本和数据以搜索、移除和替换文本。 例如： 二、基础知识 1.1开始、结束符号（它们同时也属于定位符） 我们先从简单的开始。假设你要写一个正则表达式规则，你会用到^和$符号，他们分别是行首符、行尾符。 例如：/^\d+[0-9]?\d+$/ 1.2句点符号 假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符： 1.3方括号符号 为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符： 1.4“或”符号
正则表达式
目录
1. 引言 2. 基本语法 3. sed 4. awk 5. 练习:在 C 语言中使用正则表达式
1. 引言
以前我们用 grep 在一个文件中找出包含某些字符串的行,比如在头文件中找出一个宏定义. 其实 grep 还可以找出符合某个模式(Pattern)的一类字符串.例如找出所有符合 xxxxx@xxxx.xxx 模式的字符串(也就是 email 地址),要求 x 字符可以是字母,数字,下划 线,小数点或减号,email 地址的每一部分可以有一个或多个 x 字符,例如 abc.d@https://www.doczj.com/doc/8f12937172.html,, 1_2@987-6.54,当然符合这个模式的不全是合法的 email 地址,但至少可以做一次初步筛选, 筛掉 a.b,c@d 等肯定不是 email 地址的字符串.再比如,找出所有符合 yyy.yyy.yyy.yyy 模 式的字符串(也就是 IP 地址),要求 y 是 0-9 的数字,IP 地址的每一部分可以有 1-3 个 y 字 符. 如果要用 grep 查找一个模式,如何表示这个模式,这一类字符串,而不是一个特定的字符串 呢?从这两个简单的例子可以看出,要表示一个模式至少应该包含以下信息: 字符类(Character Class):如上例的 x 和 y,它们在模式中表示一个字符,但是取 值范围是一类字符中的任意一个. 数量限定符(Quantifier): 邮件地址的每一部分可以有一个或多个 x 字符,IP 地址 的每一部分可以有 1-3 个 y 字符 各种字符类以及普通字符之间的位置关系:例如邮件地址分三部分,用普通字符@和. 隔开,IP 地址分四部分,用.隔开,每一部分都可以用字符类和数量限定符描述.为 了表示位置关系,还有位置限定符(Anchor)的概念,将在下面介绍.
规定一些特殊语法表示字符类,数量限定符和位置关系,然后用这些特殊语法和普通字符一 起表示一个模式,这就是正则表达式(Regular Expression).例如 email 地址的正则表达式 可以写成[a-zA-Z0-9_.-]+@[a-zA-Z0-9_.-]+\.[a-zA-Z0-9_.-]+,IP 地址的正则表达式可以 写成[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}.下一节介绍正则表达式的语法, 我们先看看正则表达式在 grep 中怎么用.例如有这样一个文本文件 testfile:
192.168.1.1
第 1 页 共 10 页
正则表达式是JA V A语言中比较困难的内容我从网上找了一篇很不错的文章愿与大家分享共同进步 内容如下： 正则表达式之道 原著：Steve Mansour sman@https://www.doczj.com/doc/8f12937172.html, Revised: June 5, 1999 (copied by jm /at/ https://www.doczj.com/doc/8f12937172.html, from https://www.doczj.com/doc/8f12937172.html,/%7esman/regexp.htm, after the original disappeared! ) 翻译：Neo Lee neo.lee@https://www.doczj.com/doc/8f12937172.html, 2004年10月16日 英文版原文 译者按：原文因为年代久远，文中很多链接早已过期（主要是关于vi、sed等工具的介绍和手册），本译文中已将此类链接删除，如需检查这些链接可以查看上面链接的原文。除此之外基本照原文直译，括号中有“译者按”的部分是译者补充的说明。如有内容方面的问题请直接和Steve Mansor联系，当然，如果你只写中文，也可以和我联系。 目录 什么是正则表达式 范例 简单 中级（神奇的咒语） 困难（不可思议的象形文字） 不同工具中的正则表达式 什么是正则表达式 一个正则表达式，就是用某种模式去匹配一类字符串的一个公式。很多人因为它们看上去比较古怪而且复杂所以不敢去使用——很不幸，这篇文章也不能够改变这一点，不过，经过一点点练习之后我就开始觉得这些复杂的表达式其实写起来还是相当简单的，而且，一旦你弄懂它们，你就能把数小时辛苦而且易错的文本处理工作压缩在几分钟（甚至几秒钟）内完成。正则表达式被各种文本编辑软件、类库（例如Rogue Wave的tools.h++）、脚本工具（像awk/grep/sed）广泛的支持，而且像Microsoft的V isual C++这种交互式IDE也开始支持它了。 我们将在如下的章节中利用一些例子来解释正则表达式的用法，绝大部分的例子是基于vi 中的文本替换命令和grep文件搜索命令来书写的，不过它们都是比较典型的例子，其中的概念可以在sed、awk、perl和其他支持正则表达式的编程语言中使用。你可以看看不同工具中的正则表达式这一节，其中有一些在别的工具中使用正则表达式的例子。还有一个关于vi中文本替换命令（s）的简单说明附在文后供参考。 正则表达式基础
C#正则表达式之Regex类用法详解 正则表达式的本质是使用一系列特殊字符模式，来表示某一类字符串，正则表达式无疑是处理文本最有力的工具，而.NET提供的Regex类实现了验证正则表达式的方法。 Regex类表示不可变（只读）的正则表达式。它还包含各种静态方法，允许在不显式创建其他类的实例的情况下使用其他正则表达式类。 正则表达式基础概述 什么是正则表达式 在编写字符串的处理程序时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。 通常，我们在使用WINDOWS查找文件时，会使用通配符（*和?）。如果你想查找某个目录下的所有Word文档时，你就可以使用*.doc进行查找，在这里，*就被解释为任意字符串。和通配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符，它能更精确地描述你的需求——当然，代价就是更复杂。 一、C#正则表达式符号模式
说明： 由于在正则表达式中“\”、“?”、“*”、“^”、“$”、“+”、“（”、“）”、“|”、“{”、“[”等字符已经具有一定特殊意义，如果需要用它们的原始意义，则应该对它进行转义，例如希望在字符串中至少有一个“\”，那么正则表达式应该这么写：\\+。
二、在C#中，要使用正则表达式类，请在源文件开头处添加以下语句： 复制代码代码如下: using Syst https://www.doczj.com/doc/8f12937172.html, ressions; 三、RegEx类常用的方法 1、静态Match方法 使用静态Match方法，可以得到源中第一个匹配模式的连续子串。 静态的Match方法有2个重载，分别是 Regex.Match(string input,string pattern); Regex.Match(string input,string pattern,RegexOptions options); 第一种重载的参数表示：输入、模式 第二种重载的参数表示：输入、模式、RegexOptions枚举的“按位或”组合。 RegexOptions枚举的有效值是： Complied表示编译此模式 CultureInvariant表示不考虑文化背景 ECMAScript表示符合ECMAScript，这个值只能和IgnoreCase、Multiline、Complied连用ExplicitCapture表示只保存显式命名的组 IgnoreCase表示不区分输入的大小写 Ign https://www.doczj.com/doc/8f12937172.html, pace表示去掉模式中的非转义空白，并启用由#标记的注释Multiline表示多行模式，改变元字符^和$的含义，它们可以匹配行的开头和结尾 None表示无设置，此枚举项没有意义 RightToLeft表示从右向左扫描、匹配，这时，静态的Match方法返回从右向左的第一个匹配Singleline表示单行模式，改变元字符.的意义，它可以匹配换行符
Java 正则表达式 表达式意义： 1.字符 x 字符 x。例如a表示字符a \\ 反斜线字符。在书写时要写为\\\\。（注意：因为java在第一次解析时,把\\\\解析成正则表达式\\，在第二次解析时再解析为\，所以凡是不是1.1列举到的转义字符，包括1.1的\\,而又带有\的都要写两次） \0n 带有八进制值 0的字符 n (0 <= n <= 7) \0nn 带有八进制值 0的字符 nn (0 <= n <= 7) \0mnn 带有八进制值 0的字符 mnn（0 <= m <= 3、0 <= n <= 7） \xhh 带有十六进制值 0x的字符 hh \uhhhh 带有十六进制值 0x的字符 hhhh \t 制表符 ('\u0009') \n 新行（换行）符 ('\u000A') \r 回车符('\u000D') \f 换页符 ('\u000C') \a 报警 (bell) 符('\u0007') \e 转义符 ('\u001B') \c x 对应于 x 的控制符 2.字符类 [abc] a、b或 c（简单类）。例如[egd]表示包含有字符e、g或d。 [^abc] 任何字符，除了 a、b或 c（否定）。例如[^egd]表示不包含字符e、g或d。 [a-zA-Z] a到 z或 A到 Z，两头的字母包括在内（范围） [a-d[m-p]] a到 d或m到 p：[a-dm-p]（并集） [a-z&&[def]] d、e或 f（交集） [a-z&&[^bc]] a到 z，除了 b和 c：[ad-z]（减去） [a-z&&[^m-p]] a到 z，而非m到 p：[a-lq-z]（减去） 3.预定义字符类(注意反斜杠要写两次，例如\d写为\\d)任何字符 （与行结束符可能匹配也可能不匹配） \d 数字：[0-9] \D 非数字： [^0-9] \s空白字符：[ \t\n\x0B\f\r] \S 非空白字符：[^\s] \w 单词字符：[a-zA-Z_0-9] \W 非单词字符：[^\w] 4.POSIX 字符类（仅 U S-ASCII)(注意反斜杠要写两次，例如\p{Lower}写为\\p{Lower}) \p{Lower} 小写字母字符：[a-z]。 \p{U pper} 大写字母字符：[A-Z] \p{A SCII} 所有 A SCII：[\x00-\x7F] \p{A lpha} 字母字符：[\p{Lower}\p{U pper}] \p{Digit} 十进制数字：[0-9] \p{A lnum} 字母数字字符：[\p{A lpha}\p{Digit}] \p{P unc t} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ \p{Graph} 可见字符：[\p{A lnum}\p{Punc t}] \p{P rint} 可打印字符：[\p{Graph}\x20]
Perl正则表达式讲解 摘自《Perl编程详解》目录：
9．3．1原则1 正则表达式有三种形式：匹配、替换和转换。 在表 9-1 中列有三种正则表达式运算符。 接下来对每一个表达式给出详尽解释。 匹配：m/并不真正是一个正则表达式，但是对于 用正则表达式难于处理的数据常使用它来进行操纵。因 此，tr/[0-9]/9876543210.组成1223456789，987654321 等字符串。 通过使用＝~(用英语讲:does ，与“进行匹配”同) 和!~(英语:doesn't ，与“不匹配”同)把这些表达式捆绑 到标量上。作为这种类型的例子，下面我们给出六个示例 正则表达式及相应的定义： $scalar $scalarName =~ s/a/b;Name =~ s/a/b;Name =~ s/a/b; # substitute the character a for b, and return true if this can happern # substitute the character a for b, and return true if this can happern $scalarName =~ m/a;$scalarName =~ m/a; # does the scalar $scalarName have an a in it? # does the scalar $scalarName have an a in it? ~ tr/A $scalarName =~ tr/A--Z/a Z/a--# translate all capital letter with lower case ones, and retur z/; # translate all capital letter with lower case ones, and return ture n ture if this happens if this happens $scalarName !~ s/a/b/;$scalarName !~ s/a/b/; # substitute the character a for b, and return false if this indeed happens.happens. $scalarName !~ m/a/;$scalarName !~ m/a/; # does the scalar $scalarName match the character a? Return false if it does.if it does. $scalarName !~ tr/0$scalarName !~ tr/0--9/a 9/a--j/;j/; # translate the digits for the letters a thru j, and return false if this happens.if this happens. 如果我们输入像 horned toad =~ m/toad/ 这样的代码，则出现图 9-1 所示情况： 另外，如果读者正在对特定变量 $_ 进行匹配(读者可能在while 循环，map 或grep 中使用)，则可以不用!~和=~。因而，以下所有代码都会合法： my @elemente = (' al' ,' a2' ,my @elemente = (' al' ,' a2' ,' a3' ,' a4' ,' a5' );' a3' ,' a4' ,' a5' );' a3' ,' a4' ,' a5' ); foreach (@elements) {s/a/b/;}foreach (@elements) {s/a/b/;} 程序使 @elements 等于b 1，b2．b3，b4，b5。另外： while(<$FD>) {print if (m/ERBOR/);} while(<$FD>) {print if (m/ERBOR/);}
相关主题
文本预览