[Java] Java正则表达式

本主题由 onions 于 2007-11-20 10:49 关闭

onions

管理员

Rank: 9 Rank: 9 Rank: 9

1^# 大中小发表于 2007-4-17 15:32 只看该作者

Java正则表达式

正则表达式用来指定字符串模式。当你需要定位匹配某种模式的字符串时就可以使用正则表达式。例如，我们下面的一个例程就是在一个HTML文件中通过查找字符串模式<a href="...">来定位所有的超链接。5 e: ~; {# v9 O0 d. N
! o3 I- ~, w# p7 K
当然，为了指定一种模式，使用...这种记号是不够精确的。你需要精确地指定什么样的字符排列是一个合法的匹配。当描述某种模式时，你需要使用一种特殊的语法。0 O* ?* ~' Y) T6 n: G6 a
  V: ?+ f! q) P( v
这里有一个简单例子。正则表达式' @% c0 r) f. v  }' A
[Jj]ava.+1 Z: a' I6 X+ y) `
匹配下列形式的任何字符串：9 z) C" a0 `  U+ k, a& Y

首字母是J或j

后续的三个字母是ava

字符串的剩余部分由一个或多个任意字符组成

1 c5 z# k5 b/ B
例如，字符串“javaness”匹配这个特殊的正则表达式，但是字符串“Core Java”却不匹配。

如你所见，你需要了解一点语法来理解正则表达式的含意。幸运的是对于大多数的用途，使用少量的简单构造（straightforward constructs）就已足够。

字符类是可选自符的集合，用‘[’封装，比如[Jj],[0-9],[A-Za-z]或[^0-9]。这里的-表示范围（Unicode落在两个边界之间的所有字符），^表示求补（指定字符外的所有字符）。

有许多预定以的字符类，像\d（数字）或\p{Sc}（Unicode货币符号），见表12-8和12-9。

大多数字符与它们自身匹配，像上例中的ava字符。

符号.匹配任何字符（可能行终止符（line terminators）除外，这依赖于标识设置（flag settings））

\用作转义符，比如\.匹配一个句点，\\匹配一个反斜杠。

^和$分别匹配行头和行尾

如果X和Y都是正则表达式，则XY表示“X的匹配后面跟着Y的匹配”。X|Y表示“任何X或Y的匹配”

可以将量词（quantifier）用到表达式中，X+ 表示X重复1次或多次，X* 表示X重复0次或多次，X? 表示X重复0次或1次

默认地，一个量词总是与使总体成功匹配的最长的可能重复匹配。可以加上后缀？（称为reluctant或stingy 匹配，用以匹配最小的重复数），和+（称为possessive或贪婪匹配，用以即使在总体匹配失败的情况下也匹配最大的重复数）来更改这种属性。

( j- Q7 ^2 S7 V$ D8 b- ^5 c
例如，字符串cab匹配[a-z]*ab，但不匹配[a-z]*+ab。第一种情况下，[a-z]*只匹配字符c，因此字符ab正好与模式的剩余部分匹配。但是贪婪版本[a-z]*+就与字符cab匹配，模式的剩余部分ab就匹配失败（，这样总体也就匹配失败）。
/ c, a7 m9 T. U5 T4 g L, D8 T2 \, ]- `

可以使用分组来定义子表达式。将分组封装在（）中，如([+-]?)([0-9]+)。然后你可以让模式匹配符（the pattern matcher）返回每个分组的匹配，或者使用\n来回引分组（refer back to a group with \n），其中n是组号（以\1起始）

1 y& {  t# g' x3 l4 }4 H3 v( d
这里有一个稍微有点复杂却又很有用的正则表达式－－它用来描述十进制和十六进制的整数。
[+-]?[0-9]+|0[Xx][0-9A-Fa-f]+1 {7 K5 c  Y4 Y4 ?

不幸的是，在使用正则表达式的各种程序和库之间，它的语法还没有完全标准化。对基本的构造上已达成了共识，但在细节方面有许多令人“抓狂”的区别（many maddening differences）。Java的正则表达式类使用了与Perl语言类似的语法，但也不尽相同。表12-8显示了Java语法的所有正则表达式构造。要了解更多关于正则表达式的信息，请参考Pattern类的API文档，或者Jeffrey E. F. Friedl的著作《Mastering Regular Expressions》(O'Reilly and Associates, 1997)（刚去第二书店查了一下，东南大学出版社已经引入了其第二版，影印）: s9 Z. l6 a+ s! A0 X% o

表12-8 正则表达式语法
语法                                                       解释" M8 `2 l; s& _8 y
字符: m9 X* I  o( `* ^# j" e
c                                                          字符c# Q! r* U  r5 T+ Y5 M* D
\unnnn, \xnn, \0n, \0nn, \0nnn       带有十六或八进制值的代码单元2 M9 \8 b! [% F4 m% e1 P+ h
\0n                                        八进制0n代表的字符（0<=n<=7）
( x  J0 Z% Z7 g# F; n- O7 D( F
\0nn                                        八进制0nn代表的字符(0<=n<=7); D6 E: A' {- T7 M! W$ E8 D+ H3 [
2 g7 C+ g( k- I  z# d4 o
\0mnn                                  八进制0mnn代表的字符(0<=m<=3,0<=n<=7)4 L' B3 ~# O3 U4 C

\xnn                                        十六进制 0xnn所代表的字符
  S2 m. \6 V9 u& o' b
\uhhhh                                  十六进制 0xhhhh所代表的字符

\t, \n, \r, \f, \a, \e                                  控制字符，依次是制表符，换行符，回车符，换页符，报警符和转义符3 D+ r) i! N! H6 g8 n4 L
\cc                                                       控制字符中出现的相应字符c
字符类
[C1C2. . .]                      C1、C2……中的任何字符。Ci可以是字符，字符范围（C1-C2）或者字符类。
[^. . .]                               字符类的补集
[ . . . && . . .]                   两个字符类的交集2 H9 |+ \3 _3 S. `& a# P: n1 C, Z4 [
预定义字符类  g2 X' P5 J& @& R1 O
.                                     除行终止符外的任何字符（如果DOTALL标志置位，则表示任何字符）6 v" m7 d( ~, l
\d                                     数字[0-9]
\D                                  非数字[^0-9]
\s                                  空白字符[\t\n\r\f\x0B]
\S                                  非空白字符+ a5 K: Y+ Y5 T) ^6 V. J3 I4 i
\w                                  单词字符[a-zA-Z0-9_]% W; Y0 [* i  z7 n! n7 |6 L  V  i1 h
\W                                  非单词字符6 S- e0 s( r  r3 J7 ?
\p{name}                      一个指定的字符类，见表12-9* k* w7 v# C6 q0 n! g
\P{name}                      指定字符类的补集. k0 j1 f# m  J3 d  a
边界匹配符6 U% Q6 C$ `, F7 ]$ _$ R
^ $                                  输入的开头和结尾(在多行模式(multiline mode)下是行的开头和结尾)
\b                                  单词边界' x' J+ ?; l3 p( l- [
\B                                  非单词边界/ g; Z" f* L( x9 Z1 `3 t% F
\A                                  输入的开头
\z                                  输入的结尾6 e$ U- F0 T0 R- D' C& p, o( N
\Z                                  除最后行终止符之外的输入结尾
\G                                  上个匹配的结尾3 @7 P7 B2 v( w
量词" p0 @7 Y/ Z( R( e1 V0 m* a9 A
X?                                  可选的X（即X可能出现，也可能不出现）
X*                                  X，可以重复0次或多次
X+                                  X，可以重复1次或多次
X{n} X{n,} X{n,m}       X重复n次，至少重复n次，重复n到m次
量词后缀6 ]0 V  F4 J) N! r
?                                  设默认（贪婪）匹配为reluctant匹配- A2 M  {' |6 x$ F8 G2 @( c9 [& n
+                                  设默认（贪婪）匹配为possessive匹配9 n& V0 K8 }4 H% E0 h
集合操作4 n% `  v, @+ U' \1 t0 r& u
XY                               X的匹配后面跟着Y的匹配% g# E; y8 S3 y( y1 Q% P$ _9 k
X|Y                               X或Y的匹配) `/ M( h# ?# J: P( p
分组
(X)                               匹配X并且在一个自动计数的分组中捕获它' |1 T) J" m) S5 Z, t
\n                               与第n个分组的匹配
转义% _0 x. l$ d. f7 p( c2 _
\c                                  字符c（必须不是字母）
\Q...\E                         逐字地引用...
（？...）                      特殊构造，看Pattern类的API' X. ^1 a/ b+ G! n6 S9 _
% i. A; q1 [- M0 g3 d& G/ r. |
正则表达式的最简单使用是测试一个特殊的字符串是否与之匹配。这里有一个Java写的测试程序。首先从表示正则表达式的字符串构造一个Pattern对象。然后从该模式获得一个Matcher对象，并且调用它的matches()方法：3 R- U& P: ~$ b6 D
Pattern pattern = Pattern.compile(patternString);* j4 Y& A  O- C' W9 \7 N

Matcher matcher = pattern.matcher(input);
. S5 k& @$ J5 m/ n' J9 l
if (matcher.matches()) . . .

+ e% v* @8 V' ^
表12.9 预定义的字符类名（Predefined Character Class Names）
Lower                      小写的ASII字符[a-z]% y/ u( o* S& @- A
Upper                      大写的ASCII字符[A-Z]) |5 l( u9 V* ^$ m4 A, N. |
Alpha                         ASCII字母[A-Za-z]! v! j& y4 n; S) x9 X( ~9 \) u2 `
Digit                         ASCII 数字 [0-9]) K4 ?3 Z0 v$ Z" n5 k; c
Alnum                      ASCII 字母或数字[A-Za-z0-9]
Xdigit                      十六进制数字[0-9A-Fa-f] 0 e2 R6 h4 |! R
Print or Graph       可打印的ASCII字符[\x21-\x7E]4 Q4 }9 [" B  K, q# ?
Punct                      非字母或数字ASCII [\p{Print}&&\P{Alnum}]
ASCII                      所有ASCII字符 [\x00-\x7F]. Y5 e, H3 T' Q
Cntrl                         ASCII控制字符[\x00-\x1F]% f; {" p. h3 C) |
Blank                      空格符或制表符[ \t]5 K: K( j7 p" J& r: J
Space                      空白符 [ \t\n\r\f\0x0B]+ U) X/ R8 j, ]7 q8 C
javaLowerCase    取决于Character.isLowerCase()的小写字符
javaUpperCase    取决于Character.isUpperCase()的大写字符
javaWhitespace    取决于Character.isWhitespace()的空白符' O5 P2 N1 E# ?8 c+ N- n2 P! `
javaMirrored          取决于Character.isMirrored()的Mirrored（？） $ K' j9 Z+ m* g3 [& g3 x
InBlock                   这里的Block是unicode字符的块名，用空格隔开，比如BasicLatin 或 Mongolian。块名列表                               参考http://www.unicode.org
Category 或InCategory    这里的Category是Unicode字符的种类名，比如L（字母）或者Sc（货币符号）。种类                                     名列表参考http://www.unicode.org

matcher的输入可以是实现CharSequence接口的任何类对象，像String，StringBuilder或CharBuffer。! n' u' O7 `& h0 _8 M7 Q* p+ }" m5 d3 c
9 S. C& I4 Y' q
当编译模式时，可以设置一个或多个标志，例如
Pattern pattern = Pattern.compile(patternString,

Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
  P# g2 u( `' d! t

下面六个标志都是支持的：+ V: |4 \6 L) `
CASE_INSENSITIVE：匹配字符时与大小写无关，该标志默认只考虑US ASCII字符。
9 i6 w" Z0 p( c# j% ?
UNICODE_CASE：当与CASE_INSENSITIVE结合时，使用Unicode字母匹配& ^" {2 i0 t5 h& J  {6 q
2 l" K% u) j2 J3 f5 P
MULTILINE：^和$匹配一行的开始和结尾，而不是整个输入1 G: Y& l, }: ~$ U; i9 E

UNIX_LINES：当在多行模式下匹配^和$时，只将'\n'看作行终止符6 _$ |- V) j5 y
9 N+ D4 ]. c4 F3 e& t$ @* h
DOTALL: 当使用此标志时，.符号匹配包括行终止符在内的所有字符
8 l) d/ i1 J2 d. }- g
CANON_EQ: 考虑Unicode字符的规范等价+ U; z( s$ k5 h$ J4 s! m

   如果正则表达式包含分组，Matcher对象能够揭示分组边界。方法. x) I5 L2 v7 x# R6 T
int start(int groupIndex)& ~. F# x5 G+ `1 w( m
1 o, {, f8 z+ R
int end(int groupIndex); _) H' O- C. x2 ~9 L8 [  _

返回某个特殊分组的起始索引和结尾后索引（past-the-end index ）。
通过调用String group(int groupIndex)，你可以简单地得到匹配的字符串。3 g/ X* P, O8 _: d. J. y
第0个分组代表所有的分组，第一个实际分组的索引是1。调用groupCount来获得总的分组数。
. ^8 c1 [" z% n
   使用开放圆括号来安排嵌套分组。例如，给定模式((1?[0-9]):([0-5][0-9]))[ap]m，并且输入11:59am,Matcher对象报告下列分组" m( e2 k' S6 i
((1?[0-9]):([0-5][0-9]))[ap]m
并输入& @3 l0 |: G/ w: L: \" ?
11:59am1 Y* }3 R! V7 f, U
matcher报告下列分组1 @4 Z; i* S! K- o1 `

分组索引  起始  结束  字符串) w7 s/ f) Y/ b2 b
0             0       7    11;59am
1             0       5    11:59) B# J( u0 B  N8 w: W2 u, P) [
2             0       2    11, s+ U% Y- S$ M) ]
3             3       5    59
1 a1 A; P8 D$ k5 Z% y) C* f0 v8 f
例12－9提示输入一个模式和一个欲匹配的字符串。它将输出输入的字符串是否匹配模式。如果输入匹配包含分组的模式，程序将会使用圆括号来打印分组边界，如((11):(59))am3 [, P; s6 z  y% t% v# f7 D  A

Example 12-9. RegexTest.java
1. import java.util.*;
2. import java.util.regex.*;9 {/ N/ d' K& T
3.6 b& s: V7 y+ ~" P0 q$ k7 P) f
4. /**
5. This program tests regular expression matching.
6. Enter a pattern and strings to match, or hit Cancel
7. to exit. If the pattern contains groups, the group
8. boundaries are displayed in the match.) f; ]8 m! }. X- G, _8 `
9. */
10. public class RegExTest
11. {3 @, @4 e- ?0 U: p5 F
12. public static void main(String[] args)
13. {! V6 S! A; f8 D+ v
14.    Scanner in = new Scanner(System.in);/ ?& w9 o4 n  B9 O- l
15.    System.out.println("Enter pattern: ");
16.    String patternString = in.nextLine();4 ?' B2 Q8 z$ y. E, |% s
17.8 Z; s' b: N* c# z
18.    Pattern pattern = null;0 E9 j( L& x; A" Q1 u
19.    try8 I& h. I+ T1 o3 [- T; p  w9 m( @$ n1 @
20.    {1 Q& {2 E  E# D/ t7 k1 B/ G- c
21.       pattern = Pattern.compile(patternString);
22.    }
23.    catch (PatternSyntaxException e)
24.    {
25.       System.out.println("Pattern syntax error");, t9 |: j8 k+ ~. h# E8 \0 Y
26.       System.exit(1);$ J; d7 M5 ^5 U6 F! n( ?
27.    }
28.3 j0 t- }7 D5 \
29.    while (true)4 U) M& x" a  ]5 p5 x5 T( _2 a, ~+ E9 R
30.    {& Z0 O' w+ B" x6 N9 k& r( d
31.       System.out.println("Enter string to match: ");
32.       String input = in.nextLine();2 p" m! e5 W3 }, |( m  v- [
33.       if (input == null || input.equals("")) return;% d: ^" s. v6 d9 @' h
34.       Matcher matcher = pattern.matcher(input);. o! r: G$ D/ _  t& x% J
35.       if (matcher.matches())1 ?7 Q8 q0 Y0 C. V! y( ]5 T
36.       {
37.          System.out.println("Match");
38.          int g = matcher.groupCount();
39.          if (g > 0)
40.          {5 x- K( T# G# c+ F- {
41.             for (int i = 0; i < input.length(); i++), B$ U3 ]: m, i: I) z# ^' D% |- T
42.             {
43.                for (int j = 1; j <= g; j++). M9 u5 O  L6 x9 G- \
44.                   if (i == matcher.start(j)); _6 G( ^' H  y! b6 y7 `" [) ]
45.                      System.out.print('(');
46.                System.out.print(input.charAt(i));( N! I0 Z, [% ?! k) v+ ]8 w
47.                for (int j = 1; j <= g; j++). N" [0 n7 m( c' X: w: @
48.                   if (i + 1 == matcher.end(j))
49.                      System.out.print(')');) L3 B0 B* w6 \/ {8 A& m) o
50.             }
51.             System.out.println();, l7 q# v0 ]( b5 h6 U' O
52.          }
53.       }; \1 [. b; B+ f/ `# g! Z' W
54.       else
55.          System.out.println("No match");
56.    }. T! d: z. \, }: z" F5 u+ a
57. }
58. }

   通常地，你不希望匹配整个输入到某个正则表达式，而是希望在输入中找出一个或多个匹配的子字符串。使用Matcher类的find方法来寻找下一个匹配。如果它返回True，再使用start和end方法找出匹配的范围。: _  k& C- X$ h6 L3 M4 `) t3 z! s$ x2 j
3 j( k9 w' z. ^# v# g) P1 T
while (matcher.find())
9 J: h" N( ^% C6 j$ {7 R
{2 V* X1 W+ i  \! ]

int start = matcher.start();
  p- _5 V; l( z# r3 n  g
int end = matcher.end();

String match = input.substring(start, end);3 s4 h: f: z3 r5 h
7 N6 `/ X  c  Q& \+ [5 y# s- P  D
. . .
. }- z3 v* ?- A/ }% U# I
}7 ~% w$ O  @! Y. _& S
$ m4 y& t4 a  g

例12-10用到了这种机制。它在一个网页中定位所有的超文本引用并打印它们。为运行程序，在命令行提供一个URL，比如' ]; _' \' q, z) g
java HrefMatch http://www.horstmann.com# }9 X. G9 O4 A

Example 12-10. HrefMatch.java
1. import java.io.*;
2. import java.net.*;
3. import java.util.regex.*;
4.5 U, G' V: G( }/ }
5. /**5 w/ {( U" Y, Y- R2 R+ |
6. This program displays all URLs in a web page by: z$ N5 W5 t, W  p
7. matching a regular expression that describes the0 y& p, ?- x6 r& i; X, R5 }8 D
8. <a href=...> HTML tag. Start the program as7 \- q& z3 ?0 R" c$ _1 x& n
9. java HrefMatch URL
10. */( k0 C" q# a& ^7 J/ `8 A2 T
11. public class HrefMatch
12. {
13. public static void main(String[] args)
14. {
15.    try6 ^7 H% {) x- z$ B# J
16.    {
17.       // get URL string from command line or use default
18.       String urlString;4 }1 ]/ r# D% F% |4 p
19.       if (args.length > 0) urlString = args[0];$ `3 W4 }, N1 P: Q
20.       else urlString = "http://java.sun.com";
21.
22.       // open reader for URL
23.       InputStreamReader in = new InputStreamReader(new URL(urlString).openStream());* q* Z5 ^, H6 V* R# [6 \; h% P
24.
25.       // read contents into string buffer
26.       StringBuilder input = new StringBuilder();' `# ^1 x$ O% s
27.       int ch;8 ~! h1 a! W, g7 L- N7 J7 K0 C; N
28.       while ((ch = in.read()) != -1) input.append((char) ch);: ]! ~9 b" M, c1 q( {/ d2 O
29.7 z3 w. |( P& G, J6 Q/ p
30.       // search for all occurrences of pattern! A7 w1 |( A9 F& U. ~, f8 F9 c
31.       String patternString = "<a\\s+href\\s*=\\s*(\"[^\"]*\"|[^\\s>])\\s*>";
32.       Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);. n* w: w- @+ O1 S
33.       Matcher matcher = pattern.matcher(input);6 U5 I$ ?( U8 O5 V1 u, f; K
34.# h, P% T  J' l& M
35.       while (matcher.find())1 J! k7 ^+ \8 f: A2 i4 a' r
36.       {
37.          int start = matcher.start();! O8 s5 C3 |  u% b' \) b
38.          int end = matcher.end();3 j0 H' O, r; A3 B- ~0 ]
39.          String match = input.substring(start, end);
40.          System.out.println(match);9 d/ M7 G, N3 N* T$ v1 h
41.       }
42.    }( O3 }9 N" ?! X& w
43.    catch (IOException e)! ^$ ?& g' x$ A% |4 b  y
44.    {3 j' s5 p7 o* u8 G: _
45.       e.printStackTrace();
46.    }
47.    catch (PatternSyntaxException e)( Z- T2 h: k& r' k2 X
48.    {' t- M  M( P7 d6 j# V  K6 o
49.       e.printStackTrace();/ s: D6 @. x% i0 p
50.    }  v0 ?. Y3 ?. m
51. }
52. }

Matcher类的replaceAll方法用一个替换字符串代替出现的所有正则表达式的匹配。比如，下列指令用#替换所有数字序列
+ d& B( ~* |0 l. J. {! B% w% f+ I6 |
Pattern pattern = Pattern.compile("[0-9]+");& S" c# c$ u* R/ O

Matcher matcher = pattern.matcher(input);0 o$ [+ @$ W! A: o# P
( {9 I! A6 V8 a3 P
String output = matcher.replaceAll("#");

替换字符串可以包含模式中的分组引用：$n被第n个分组替换。替换文本中出现$时，使用\$来包含它。8 W  |5 M, \7 h3 N3 k
replaceFirst方法只替换模式的第一次出现。3 q3 Q9 T8 E' `2 f8 @4 T
! A. b, y2 V$ s: O
最后讲一点，Pattern类有一个split方法，它类似于字符串tokenizer。它使用正则表达式匹配作边界，将输入分离成字符串数组。比如，下面的指令将输入分离成记号（token），
9 n) }+ g/ r0 |
Pattern pattern = Pattern.compile("\\s*\\p{Punct}\\s*");
6 T3 Z5 @' h1 r
String[] tokens = pattern.split(input);( ?3 D# c7 A( M8 B

; n) C; F$ M( f1 D; L+ ^7 l
类
java.util.regex.Pattern 1.4
方法
static Pattern compile(String expression)
static Pattern compile(String expression, int flags)2 R+ o' g. _2 f, l& e. u# ?7 G4 Y
编译正则表达式字符串到pattern对象用以匹配的快速处理
参数:
expression 正则表达式
flags          下列标志中的一个或多个 CASE_INSENSITIVE, UNICODE_CASE, MULTILINE, UNIX_LINES, DOTALL, and CANON_EQ9 V; G! x0 E; I4 }9 Y
9 e6 q7 Y$ t2 n1 ?* A. p
Matcher matcher(CharSequence input)7 |; m" s, }& D; J
返回一个matcher对象，它可以用来在一个输入中定位模式匹配$ @! |6 o2 E9 p* G7 X# ^/ r% [
8 t! _2 [, E: k1 T
String[] split(CharSequence input)" I7 m, ]( P: |7 I
String[] split(CharSequence input, int limit)
将输入字符串分离成记号，并由pattern来指定分隔符的形式。返回记号数组。分隔符并不是记号的一部分。
参数:
input 分离成记号的字符串
limit 生成的最大字符串数。
类
java.util.regex.Matcher 1.4
方法
boolean matches()
返回输入是否与模式匹配
* n4 T7 Y+ `' w, _5 e8 n4 a- y
boolean lookingAt()
如果输入的起始匹配模式则返回True
' r! B; |" n" {2 t2 D$ |
boolean find()
boolean find(int start)& @6 Z+ D+ |1 W& X2 Q) [- B
尝试查找下一个匹配，并在找到匹配时返回True' J; g; q/ o1 ?
参数:1 j# z1 h1 E5 O- {. b
start  开始搜索的索引1 d' F1 f" M/ `% k5 x6 t: n. l- }

int start()0 v0 a( m- m2 s
int end(), Y3 {9 T- X1 i9 Q
返回当前匹配的起始位置和结尾后位置
/ q8 D: O( _+ K: p# P8 b
String group()
返回当前匹配5 w! n7 x" G9 y

int groupCount()+ o" w0 T$ M  O* l1 \1 U: R/ L- m
返回输入模式中的分组数( n6 {) r& X. g* c

int start(int groupIndex)
int end(int groupIndex)( G$ N8 y  ?: R0 f5 _7 [# g& Z- u
返回一个给定分组当前匹配中的起始位置和结尾后位置
参数:6 y  P9 l7 ~& r
groupIndex分组索引（从1开始），0表示整个匹配! o/ w% |! w( u  a

String group(int groupIndex)- t& A* g+ z4 n8 B9 i
返回匹配一个给定分组的字符串: q  X4 c6 {$ [4 L  n* r% G
参数:
groupIndex
分组索引（从1开始），0表示整个匹配. y$ K* u# n3 }' E" q
. {7 |; P6 H. ]3 A$ O
String replaceAll(String replacement)3 R, Y$ f9 m9 ?, s& f4 W
String replaceFirst(String replacement)
返回从matcher输入得到的字符串，但已经用替换表达式替换所有或第一个匹配# m! [& Y  @  b
参数:
replacement 替换字符串 0 f- h$ U: K! L- U- y' L1 y& n

Matcher reset()
Matcher reset(CharSequence input)3 ]) H! k1 G$ Y8 z
复位mather状态。

TOP

游客 202.49.183.x 未注册	2^# 大中小发表于 2007-11-6 11:51 cialis 提示: 该帖被管理员或版主屏蔽
	TOP

‹‹ 上一主题 | 下一主题 ››

[Java] Java正则表达式

Java正则表达式

cialis