Java 正则表达式(2012.08.02)

(注:该文章转载于百度文库。地址:http://wenku.baidu.com/view/8ad29fee0975f46527d3e14f.html,由于图片太多上传太麻烦,可以进原地址学习。)

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的字符 mnn0 <= m <= 30 <= n <= 7
\xhh
带有十六进制值 0x的字符 hh
\uhhhh
带有十六进制值 0x的字符 hhhh
\t
制表符 ('\u0009')
\n
新行(换行)符 ('\u000A')
\r
回车符 ('\u000D')
\f
换页符 ('\u000C')
\a
报警 (bell) ('\u0007')
\e
转义符 ('\u001B')
\cx
对应于 x 的控制符
2.字符类
[abc]ab c(简单类)。例如[egd]表示包含有字符egd
[^abc]
任何字符,除了 ab c(否定)。例如[^egd]表示不包含字符egd
[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 字符类(仅 US-ASCII)(注意反斜杠要写两次,例如\p{Lower}写为\\p{Lower})
\p{Lower}
小写字母字符:[a-z]
\p{Upper}
大写字母字符:[A-Z]
\p{ASCII}
所有 ASCII[\x00-\x7F]
\p{Alpha}
字母字符:[\p{Lower}\p{Upper}]
\p{Digit}
十进制数字:[0-9]
\p{Alnum}
字母数字字符:[\p{Alpha}\p{Digit}]
\p{Punct}
标点符号:!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}
可见字符:[\p{Alnum}\p{Punct}]
\p{Print}
可打印字符:[\p{Graph}\x20]
\p{Blank}
空格或制表符:[ \t]
\p{Cntrl}
控制字符:[\x00-\x1F\x7F]
\p{XDigit}
十六进制数字:[0-9a-fA-F]
\p{Space}
空白字符:[ \t\n\x0B\f\r]
5.java.lang.Character (简单的 java字符类型)
\p{javaLowerCase}
等效于java.lang.Character.isLowerCase()
\p{javaUpperCase}
等效于java.lang.Character.isUpperCase()
\p{javaWhitespace}
等效于java.lang.Character.isWhitespace()
\p{javaMirrored}
等效于java.lang.Character.isMirrored()
6.Unicode 块和类别的类
\p{InGreek} Greek
块(简单块)中的字符
\p{Lu}
大写字母(简单类别)
\p{Sc}
货币符号
\P{InGreek}
所有字符,Greek块中的除外(否定)
[\p{L}&&[^\p{Lu}]]
所有字母,大写字母除外(减去)
7.边界匹配器
^
行的开头,请在正则表达式的开始处使用^。例如:^(abc)表示以abc开头的字符串。注意编译的时候要设置参数MULTILINE,如 Pattern p =Pattern.compile(regex,Pattern.MULTILINE);
$
行的结尾,请在正则表达式的结束处使用。例如:(^bca).*(abc$)表示以bca开头以abc结尾的行。
\b
单词边界。例如\b(abc)表示单词的开始或结束包含有abc,abcjjjjabc都可以匹配)
\B
非单词边界。例如\B(abc)表示单词的中间包含有abc,(jjabcjj匹配而jjabcabcjj不匹配)
\A
输入的开头
\G
上一个匹配的结尾(个人感觉这个参数没什么用)。例如\\Gdog表示在上一个匹配结尾处查找dog如果没有的话则从开头查找,注意如果开头不是dog则不能匹配。
\Z
输入的结尾,仅用于最后的结束符(如果有的话)
行结束符是一个或两个字符的序列,标记输入字符序列的行结尾。
以下代码被识别为行结束符:
新行(换行)符 ('\n')
后面紧跟新行符的回车符 ("\r\n")
单独的回车符 ('\r')
下一行字符 ('\u0085')
行分隔符 ('\u2028')
段落分隔符 ('\u2029)
\z
输入的结尾
当编译模式时,可以设置一个或多个标志,例如
Pattern pattern = Pattern.compile(patternString,Pattern.CASE_INSENSITIVE +Pattern.UNICODE_CASE);
下面六个标志都是支持的:
CASE_INSENSITIVE:匹配字符时与大小写无关,该标志默认只考虑US ASCII字符。
UNICODE_CASE:当与CASE_INSENSITIVE结合时,使用Unicode字母匹配
MULTILINE^$匹配一行的开始和结尾,而不是整个输入
UNIX_LINES当在多行模式下匹配^$时,只将'\n'看作行终止符
DOTALL: 当使用此标志时,.符号匹配包括行终止符在内的所有字符
CANON_EQ: 考虑Unicode字符的规范等价
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
ReluctantPossessive的区别在于:(注意仅限于进行.等模糊处理时)
greedy
词被看作贪婪的,因为它第一次就读入整个被模糊匹配的字符串。如果第一个匹配尝试(整个输入字符串)失败,匹配器就会在被匹配字符串中的最后一位后退一个字符并且再次尝试,重复这个过程,直到找到匹配或者没有更多剩下的字符可以后退为止。根据表达式中使用的量词,它最后试图匹配的内容是1个或者0个字符。
但是,reluctant量词采取相反的方式:它们从被匹配字符串的开头开始,然后逐步地一次读取一个字符搜索匹配。它们最后试图匹配的内容是整个输入字符串。
最后,possessive量词总是读完整个输入字符串,尝试一次(而且只有一次)匹配。和greedy量词不同,possessive从不后退。
11.Logical 运算符
XYX 后跟 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就表示ab34cdabcd
13.引用
\Nothing,但是引用以下字符
\Q Nothing
,但是引用所有字符,直到 \EQE之间的字符串会原封不动的使用(1.1中转义字符的除外)。例如, ab\\Q{|}\\\\E
可以匹配ab{|}\\
\E Nothing
,但是结束从 \Q开始的引用
14.特殊构造(非捕获)
(?:X) X
,作为非捕获组
(?idmsux-idmsux) Nothing
,但是将匹配标志由 on转为 off。比如:表达式 (?i)abc(?-i)def这时,(?i) 打开不区分大小写开关,abc 匹配
idmsux
说明如下:
i CASE_INSENSITIVE :US-ASCII字符集不区分大小写。(?i)
d UNIX_LINES :打开UNIX换行符
m MULTILINE :多行模式(?m)
UNIX
下换行为\n
WINDOWS
下换行为\r\n(?s)
u UNICODE_CASE : Unicode不区分大小写。(?u)
x COMMENTS :可以在pattern里面使用注解,忽略pattern里面的whitespace,以及"#"一直到结尾(#后面为注解)。(?x)例如(?x)abc#asfsdadsa可以匹配字符串abc
(?idmsux-idmsux: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)是不回溯的。例如被匹配的字符串为abcm
当表达式为a(?:b|bc)m是可以匹配的,而当表达式是a(?>b|bc)时是不能匹配的,因为当后者匹配到b时,由于已经匹配,就跳出了非捕获组,而不再次对组内的字符进行匹配。可以加快速度。

注意:有评论说最后一句说的有问题——“这里有问题!abcm也可被a(?>b|bc)匹配!

引言

正则表达式(regular expression)就是用一个字符串来描述一个特征,然后去验证另一个字符串是否符合这个特征。比如表达式“ab+”描述的特征是一个 'a'任意个 'b' ”,那么 'ab', 'abb','abbbbbbbbbb'都符合这个特征。

正则表达式可以用来:(1)验证字符串是否符合指定特征,比如验证是否是合法的邮件地址。(2)用来查找字符串,从一个长的文本中查找符合指定特征的字符串,比查找固定字符串更加灵活方便。(3)用来替换,比普通的替换更强大。

正则表达式学习起来其实是很简单的,不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂,一方面是因为大多数的文档没有做到由浅入深地讲解,概念上没有注意先后顺序,给读者的理解带来困难;另一方面,各种引擎自带的文档一般都要介绍它特有的功能,然而这部分特有的功能并不是我们首先要理解的。

文章中的每一个举例,都可以点击进入到测试页面进行测试。闲话少说,开始。


1. 正则表达式规则

1.1 普通字符

字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符"。表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符。

举例1:表达式 "c",在匹配字符串 "abcde",匹配结果是:成功;匹配到的内容是:"c";匹配到的位置是:开始于2,结束于3。(注:下标从0开始还是从1开始,因当前编程语言的不同而可能不同)

举例2:表达式 "bcd",在匹配字符串 "abcde",匹配结果是:成功;匹配到的内容是:"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:表达式 "[bcd][bcd]" 匹配 "abc123",匹配的结果是:成功;匹配到的内容是:"bc";匹配到的位置是:开始于1,结束于3

举例2:表达式 "[^abc]" 匹配 "abc123",匹配的结果是:成功;匹配到的内容是:"1";匹配到的位置是:开始于3,结束于4


1.5 修饰匹配次数的特殊符号

前面章节中讲到的表达式,无论是只能匹配一种字符的表达式,还是可以匹配多种字符其中任意一个的表达式,都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号,那么不用重复书写表达式就可以重复匹配。

使用方法是:"次数修饰"放在"被修饰的表达式"后边。比如:"[bcd][bcd]"可以写成 "[bcd]{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*" 在匹配 "It costs $12.5",匹配的结果是:成功;匹配到的内容是:"12.5";匹配到的位置是:开始于10,结束于14

举例2:表达式 "go{2,8}gle" 在匹配 "Ads 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:表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he isJack",匹配结果是:成功;匹配到的内容是:"Tom";匹配到的位置是:开始于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"

(d)(\w+)(d)

"\w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "\w+" 也能够匹配上最后一个 "d",但是为了使整个表达式匹配成功,"\w+" 可以 "让出" 它本来能够匹配的最后一个 "d"

由此可见,"\w+"在匹配的时候,总是尽可能多的匹配符合它规则的字符。虽然第二个举例中,它没有匹配最后一个 "d",但那也是为了让整个表达式能够匹配成功。同理,带 "*" "{m,n}" 的表达式都是尽可能地多匹配,带 "?" 的表达式在可匹配可不匹配的时候,也是尽可能的 "要匹配"。这种匹配原则就叫作 "贪婪" 模式

非贪婪模式:

在修饰匹配次数的特殊符号后再加上一个 "?"号,则可以使匹配次数不定的表达式尽可能少的匹配,使可匹配可不匹配的表达式,尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪"模式,也叫作 "勉强"模式。如果少匹配就会导致整个表达式匹配失败的时候,与贪婪模式类似,非贪婪模式会最小限度的再匹配一些,以使整个表达式匹配成功。举例如下,针对文本"dxxxdxxxd"举例:

表达式

匹配结果

(d)(\w+?)

"\w+?" 将尽可能少的匹配第一个 "d" 之后的字符,结果是:"\w+?" 只匹配了一个 "x"

(d)(\w+?)(d)

为了让整个表达式匹配成功,"\w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配,从而使整个表达式匹配成功。因此,结果是:"\w+?" 匹配 "xxx"

更多的情况,举例如下:

举例1:表达式 "<td>(.*)</td>"与字符串"<td><p>aa</p></td><td><p>bb</p></td>"匹配时,匹配的结果是:成功;匹配到的内容是"<td><p>aa</p></td><td><p>bb</p></td>"整个字符串,表达式中的"</td>"将与字符串中最后一个 "</td>"匹配。

举例2:相比之下,表达式"<td>(.*?)</td>"匹配举例1中同样的字符串时,将只得到"<td><p>aa</p></td>"再次匹配下一个时,可以得到第二个"<td><p>bb</p></td>"


2.2 反向引用 \1, \2...

表达式在匹配时,表达式引擎会将小括号 "( )"包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候,小括号包含的表达式所匹配到的字符串可以单独获取。这一点,在前面的举例中,已经多次展示了。在实际应用场合中,当用某种边界来查找,而所要获取的内容又不包含边界时,必须使用小括号来指定所要的范围。比如前面的"<td>(.*?)</td>"

其实,"小括号包含的表达式所匹配到的字符串"不仅是在匹配结束后才可以使用,在匹配过程中也可以使用。表达式后边的部分,可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\1"引用第1对括号内匹配到的字符串,"\2"引用第2对括号内匹配到的字符串……以此类推,如果一对括号内包含另一对括号,则外层的括号先排序号。换句话说,哪一对的左括号 "(" 在前,那这一对就先排序号。

举例如下:

举例1:表达式 "('|")(.*?)(\1)"在匹配" 'Hello', "World" ",匹配结果是:成功;匹配到的内容是:" 'Hello' "。再次匹配下一个时,可以匹配到 ""World" "

举例2:表达式 "(\w)\1{4,}" 在匹配 "aa bbbb abcdefg ccccc111121111 999999999",匹配结果是:成功;匹配到的内容是 "ccccc"。再次匹配下一个时,将得到 999999999。这个表达式要求 "\w" 范围的字符至少重复5次,注意与 "\w{5,}" 之间的区别

举例3:表达式"<(\w+)\s*(\w+(=('|").*?\4)?\s*)*>.*?</\1>"在匹配 "<td id='td1'style="bgcolor:white"></td>",匹配结果是成功。如果"<td>" "</td>" 不配对,则会匹配失败;如果改成其他配对,也可以匹配成功。


2.3 预搜索,不匹配;反向预搜索,不匹配

前面的章节中,我讲到了几个代表抽象意义的特殊符号:"^""$""\b"。它们都有一个共同点,那就是:它们本身不匹配任何字符,只是对 "字符串的两头" 或者 "字符之间的缝隙"附加了一个条件。理解到这个概念以后,本节将继续介绍另外一种对 "两头"或者 "缝隙"附加条件的,更加灵活的表示方法。

正向预搜索:"(?=xxxxx)""(?!xxxxx)"

格式:"(?=xxxxx)",在被匹配的字符串中,它对所处的 "缝隙"或者 "两头"附加的条件是:所在缝隙的右侧,必须能够匹配上 xxxxx这部分的表达式。因为它只是在此作为这个缝隙上附加的条件,所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "\b",本身不匹配任何字符。"\b"只是将所在缝隙之前、之后的字符取来进行了一下判断,不会影响后边的表达式来真正的匹配。

举例1:表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT,Windows 2000",将只匹配 "WindowsNT"中的 "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 stop fjdslafdj",将从头一直匹配到 "stop"之前的位置,如果字符串中没有 "stop",则匹配整个字符串。

举例4:表达式 "do(?!\w)" 在匹配字符串 "done, do, dog",只能匹配 "do"。在本条举例中,"do"后边使用 "(?!\w)" 和使用 "\b" 效果是一样的。

反向预搜索:"(?<=xxxxx)""(?<!xxxxx)"

这两种格式的概念和正向预搜索是类似的,反向预搜索要求的条件是:所在缝隙的 "左侧",两种格式分别要求必须能够匹配和必须不能够匹配指定表达式,而不是去判断右侧。与 "正向预搜索" 一样的是:它们都是对所在缝隙的一种附加条件,本身都不匹配任何字符。

举例5:表达式"(?<=\d{4})\d+(?=\d{4})"在匹配"1234567890123456"时,将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JScript.RegExp 不支持反向预搜索,因此,本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索,比如:Java 1.4以上的 java.util.regex包,.NET System.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 bbccdd efg",结果是 "bbccdd"。括号 "(?:)"范围的匹配结果不进行记录,因此 "(\w)"使用 "\1" 来引用。

3.5 常用的表达式属性设置简介:IgnorecaseSinglelineMultilineGlobal

表达式属性

说明

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|else|void|int……)\b"来匹配程序中的关键字

4.4 表达式不要匹配空字符串。否则会一直得到匹配成功,而结果什么都没有匹配到。比如:准备写一个匹配 "123""123.""123.5"".5"这几种形式的表达式时,整数、小数点、小数数字都可以省略,但是不要将表达式写成:"\d*\.?\d*",因为如果什么都没有,这个表达式也可以匹配成功。更好的写法是:"\d+\.?\d*|\.\d+"

4.5 能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0次,而这个括号整体又可以匹配无限次,那么情况可能比上一条所说的更严重,匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了,比如 .NET的正则表达式,但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环,也可以从这一点入手,查找一下是否是本条所说的原因。

4.6 合理选择贪婪模式与非贪婪模式,参见话题讨论

4.7 "|"的左右两边,对某个字符最好只有一边可以匹配,这样,不会因为 "|"两边的表达式因为交换位置而有所不同。


5. 进阶与实战

有了从本文中掌握的基础,我们可以从实践中进一步巩固我们使用正则表达式的技巧。

5.1 下载正则表达式文档 chm版本

[点击下载 chm版本]- DEELX 正则语法,包含其他高级语法的 chm版本。


5.2
下载正则工具 Regex Match Tracer 2.0试用版(正版很值得购买)

[下载 Match Tracer] -471kb


5.3
免费使用 Regex Match Tracer Web

[使用 Match Tracer Web]

Web版工具为免费使用,不受 Regex Match Tracer主程序的试用期限制。


5.4
更多深入话题及使用案例

[关于递归匹配的讨论]-讨论如何使用不支持递归的正则引擎匹配嵌套结构

[有问题与站长交流]-与站长交流和讨论

[ 本页脚本] -本页的关闭高亮功能,采用 javascript的正则表达式实现的。

比如表达式:(a+b|[cd])$

如果你曾经用过Perl或任何其他内建正则表达式支持的语言,你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语,那么正则表达式Regular Expression)就是一个字符构成的串,它定义了一个用来搜索匹配字符串的模式。

许多语言,包括Perl、PHP、Python、JavaScript和JScript,都支持用正则表达式处理文本, 一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢?本文写作时,一个包含了用正则表达式进行文本处理的Java规范需求 (Specification Request)已经得到认可,你可以期待在JDK的下一版本中看到它。

然而,如果现在就需要使用正则表达式,又该怎么办呢?你可以从Apache.org下载源代码开放的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 matchesPrefix(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(PatternMatcherInput 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标记的所有属性

第二个正则表达式如图十二所示,它把各个属性分割成名字-值对。

图十二:匹配单个属性,并把它分割成名字-值对

分割结果为:

现在我们来看看完成这个任务的Java代码。首先创建两个正则表达式字符串,用Perl5Compiler把它们编译成 Pattern对象。编译正则表达式的时候,指定Perl5Compiler.CASE_INSENSITIVE_MASK选项,使得匹配操作不区分大小 写。

接下来,创建一个执行匹配操作的Perl5Matcher对象。

假设有一个String类型的变量html,它代表了HTML文件中的一行内容。如果html字符串包含FONT标记,匹配器将返回true。此时,你可以用匹配器对象返回的MatchResult对象获得第一个组,它包含了FONT的所有属性:

接下来创建一个PatternMatcherInput对象。这个对象允许你从最后一次匹配的位置开始继续进行匹配操 作,因此,它很适合于提取FONT标记内属性的名字-值对。创建PatternMatcherInput对象,以参数形式传入待匹配的字符串。然后,用匹 配器实例提取出每一个FONT的属性。这通过指定PatternMatcherInput对象(而不是字符串对象)为参数,反复地调用 PatternMatcher对象的contains()方法完成。PatternMatcherInput对象之中的每一次迭代将把它内部的指针向前移 动,下一次检测将从前一次匹配位置的后面开始。

本例的输出结果如下:

3.3 HTML处理实例二

下面我们来看看另一个处理HTML的例子。这一次,我们假定Web服务器从widgets.acme.com移到了newserver.acme.com。现在你要修改一些页面中的链接:

执行这个搜索的正则表达式如图十三所示:

图十三:匹配修改前的链接

如果能够匹配这个正则表达式,你可以用下面的内容替换图十三的链接:

注意#字符的后面加上了$1。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。

现在,返回Java。就象前面我们所做的那样,你必须创建测试字符串,创建把正则表达式编译到Pattern对象所必需的对象,以及创建一个PatternMatcher对象:

接下来,用com.oroinc.text.regex包Util类的substitute()静态方法进行替换,输出结果字符串:

Util.substitute()方法的语法如下:

这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。第三个参数是一个 Substiution对象,它决定了替换操作如何进行。本例使用的是Perl5Substitution对象,它能够进行Perl5风格的替换。第四个 参数是想要进行替换操作的字符串,最后一个参数允许指定是否替换模式的所有匹配子串(Util.SUBSTITUTE_ALL),或只替换指定的次数。

【结束语】在这篇文章中,我为你介绍了正则表达式的强大功能。只要正确运用,正则表达式能够在字符串提取和文本修改中起到很大的作用。另外,我还介绍了如何在Java程序中通过Jakarta-ORO库利用正则表达式。至于最终采用老式的字符串处理方式(使StringTokenizercharAt,和substring),还是采用正则表达式,这就有待你自己决定了。

你可能感兴趣的:(正则表达式)