关于正则表达式---ZT

Longe

第一部分：
$ l3 @' b7 k. ?4 t0 f-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
& j' a2 d6 O) A! _  j7 F8 v6 k
$ W2 y' C! o) K% U; V# i. }$ s$ q支持多种平台

) L5 V+ g) d3 A9 _" n
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
* Z. w" a2 Z5 t* Q4 Q3 C! v
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
1 ^7 _5 Z: ?7 y( K: ~: \7 n
/ V" D+ O9 i. I! }8 {' e0 _比你想象的还要普通
% {/ j- `. }& G0 J随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
8 Y# n; F+ ^3 c' ~* k, d4 I
+ r5 Q$ I  ^+ i正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
8 r8 |  h4 D* i5 r* N2 p$ b
第二部分：
----------------------
字符匹配
4 ], @+ h- d+ \" H, i- t% t1 ]. G
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
# a. O  ?5 J. V% Y& \5 [' D% V9 s
+ R) M% i! I$ i8 B) Y4 N1 @每一个表达式都包含需要查找的指令，如表A所示。
- t  [2 w( L! Q) b. _
Table A: Character-matching regular expressions
5 t' j, p% V* A格式说明：
" J8 G5 }0 [- g3 F5 ]# Y---------------
操作：
# ~1 S4 l6 I4 Q; U, i+ n/ ]+ X( d解释：
例子：
" Z0 _& Z) q- w; g1 q结果：
----------------
2 S3 @$ K, M+ Q/ p.
Match any one character
: H; x) j8 P4 _' O! k( E& }& k/ ngrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
( d+ G8 M) ~9 j/ o/ h9 y' W2 c2 }' G-----------------
3 c; F, e; d! c8 T3 M[ ]
7 Z7 C" [; P; w4 a/ a- a, ~4 H' K& O( WMatch any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
! y5 B7 {2 S3 o6 s% f4 u6 y9 \[^ ]
- r) b( A/ v$ b6 p; d# \, e# mMatch any one character not listed between the brackets

" `# t& C6 `/ a" T8 p) E& \: tgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

+ a. b0 s! q  K: M: n) G! p; lgrep [^0-9]ord sample.txt
, V$ I5 j. B; M: p# KWill match “Aord”, “aord”, etc. but not “2ord”, etc.

. x- M4 |% r% h- Q4 N; B1 o重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
0 a) y  q# p! f: M
Table B: Regular expression repetition operators
格式说明：
---------------
操作：
解释：
例子：
结果：
2 G4 W/ N/ J6 y" o- @9 L2 }----------------
?
: Q% n) _* p8 _9 R4 d- eMatch any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
*
# {$ o9 K8 t( gMatch declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
) n" R6 V1 Z" B1 V" a; I6 \& o! R-------------------
1 k' W# }( K+ b) x& q+
7 p# Z; ?3 `' L, r2 |% vMatch declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
2 r" ]' \( i" Y--------------------
& H, X4 h0 F4 W1 L5 \  \4 ?* N{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
) k& T" B1 j) XWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
3 q& D( S4 c7 w: p  Z' qWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
Match declared element at least n times, but not more than N times
; O3 }" d* g4 v2 S0 f) y7 U- _egrep “n[e]{1,2}rd” sample.txt
2 V2 c0 j3 h# D8 \: rWill match “nerd” and “neerd”

2 v) ~8 F7 p# g$ A6 f4 S9 p- C; G第三部分：
----------------
3 I+ R% y$ i: B+ \4 N: Y( S锚
4 W! S' M* {( O1 N( R. H( N锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

# z% r* Q' u& b) X7 F* Qs/pattern_to_match/pattern_to_substitute/
* J% R- K7 R2 Z
0 r2 _" {5 G+ Z8 d, y
0 k. U0 `6 R2 J6 s$ h& n" Y* NTable C: Regular expression anchors
% U" w. D. S8 X, f% o-------------
1 g# \6 e  |: f操作
& D% {6 H; b6 c$ P" K1 p" M解释
例子
结果
---------------
^
3 I5 G% A2 H- Q7 m' e9 ~9 C6 mMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
8 G/ C. ^' w) a- r& r$ G1 v7 x+ ]---------------
# a/ O" d! H) z( d3 O& K$
Match at the end of a line
  Z# J! e$ A0 ?* M% P/ Ts/$/ blah/
Inserts “ blah” at the end of the line
; j, |0 p# Y/ w) Z+ H---------------
\<
7 C4 a$ T( \- P; h6 e% k+ T/ e$ }Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

  Q& M/ w2 E4 U. Z4 D$ @* Oegrep “\Matches “blahfield”, etc.
------------------
. g0 m% J, l) D0 l! ^\>
Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
/ A& U& X$ Q, M) j6 U6 j2 Y
% A2 V# J7 j' c4 P0 x+ V3 w, Hegrep “\>blah” sample.txt
# q: b8 ]+ Y2 A: o5 I/ F" WMatches “soupblah”, etc.
: R# ~3 q0 E. Q  e* v; _5 ~---------------
6 e5 X; x* z! q  P\b
7 B& |) N+ f3 a$ s( o* m1 U, `Match at the beginning or end of a word
egrep “\bblah” sample.txt
1 d5 N- w/ }& q' N% h5 ]Matches “blahcake” and “countblah”
$ L! f: l+ G9 @-----------------
\B
  H1 I4 d! S4 D# Q& F" EMatch in the middle of a word
% Q& I, U/ f  C# Pegrep “\Bblah” sample.txt
Matches “sublahper”, etc.

间隔
3 u/ o/ `- Z8 r+ M. q0 \
: `) Y/ {0 U) l" \) ]! lRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

egrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

$ C  a7 m: q8 P: H6 e! V% |egrep “[nm]erd” sample.txt
0 @0 ]2 m( f6 M  A' q: C3 `
1 L/ W& w7 e& s/ ^7 p+ `% g当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
3 k% Y, C, L+ x. Q& S----------------
' T- c9 E0 T: D- Q) ]+ @8 |. w3 q& o一些保留字符
7 J0 u: c. u" H: o# oRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

) c. @1 {4 s$ l/ x6 P+ q^ (carat)
0 Y9 \( X8 B4 Q' R  R1 O- K1 K. (period)
+ u4 ]4 L& m2 q7 w& |* A6 N[ (left bracket}
$ (dollar sign)
1 c- g) f3 t9 S4 J3 E3 h5 }( (left parenthesis)
) (right parenthesis)
7 Q7 F; d, @; M$ ?0 o+ R| (pipe)
* (asterisk)
+ F. p) ?, G  p9 a# j; f+ (plus symbol)
$ K' ]0 r- e$ a$ e: V$ V& M? (question mark)
6 D( T: C$ }5 j4 U: S* }2 p" E{ (left curly bracket, or left brace)
; A3 {6 u7 e  y1 ]  ]7 ~\ backslash
; P& ]& [4 Y2 v6 p' Q一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
- g; v" V- m1 h9 e
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
& d9 Y# l9 @7 b: d2 ~/ _
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
% W4 I- L( D, k1 D' o6 [% [3 H
: R$ O2 r  {( \) x# W* E总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

3 K: t( j  s" C6 W7 @6 X另外一篇文章
) Y) _: v, f. {$ r2 {& N----------------------------------------
, [1 x% W7 o0 U2 g8 I  k. @正则表达式和Java编程语言
9 ~' X1 A4 l) ~8 k-----------------------------------------
! a; P8 w$ H9 g. w: M- K# l- R类和方法

9 F* `) ^. S% D$ r' }% y6 H- O. r! ]下面的类根据正则表达式指定的模式，与字符序列进行匹配。

; {& g) q7 ]6 j/ d+ }: KPattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
  E; Q" t1 p; o4 r7 _3 [
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
; l0 N5 ]" J. L. j/ |5 `: ^8 M+ n
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

+ N# D' H6 Z9 a* b- q/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
* [% ?; T: U2 h9 F- \; v*/
. w! o5 n3 e/ A7 Y: `, Oimport java.util.regex.*;

/ `: x6 `. d/ w# d2 T/ P" npublic class Splitter {
& A: a( B2 H) w5 Bpublic static void main(String[] args) throws Exception {
: t4 g9 h$ d7 s7 P' s// Create a pattern to match breaks
; o# I  f, ~! h8 ]2 }+ v' P3 ePattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
String[] result =
$ P" I4 e# X& c, @0 D   p.split("one,two, three four , five");
( W) t; b/ L3 i# j- @) Hfor (int i=0; iSystem.out.println(result);
}
! X( \, f& e: \' j  y9 |}
) N7 A' ^. t0 r2 S
8 _5 f: Q8 L4 uMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

- S8 K' b" p( g! A通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
* J4 s+ K5 L3 i
/ m$ P/ j% ~* m" |5 ?' V8 O3 Smatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
' g. w, T1 b- Q( ]find方法将扫描输入序列，寻找下一个与模式匹配的地方。
8 y  _8 S' E3 O
! \0 w" J1 S) S( V- h这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
8 T7 c4 o6 s8 {/ n# H, ]( l6 a
8 l& y$ K$ Y# `) KappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
; b5 ~6 [* E- U! B# s! Q
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
& n, x) @3 y$ V0 ^3 r; M$ e- f
Regex情景范例
% p! _* s- P1 T+ T: |9 M
1 q6 J) Y- \8 X+ X以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
3 ^& p* F& K+ T9 _) g
简单的单词替换
* n  F8 _' ^/ _6 h# w1 f
/*
. F4 V( S9 ^" m+ W7 H/ z5 X* This code writes "One dog, two dogs in the yard."
" ]1 i. {- C/ z9 r4 u% O0 w* to the standard-output stream:
- c3 ]6 ]4 N- v# n3 z- B% w*/
import java.util.regex.*;
0 G6 q$ S- U) [) v/ q& V
+ W0 l; R% K1 u: kpublic class Replacement {
( a8 [0 e  }; ]6 j! D! Fpublic static void main(String[] args)
       throws Exception {
5 S$ [: m2 |# \5 w4 Z7 ^// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
' P0 \1 s- O. [6 i2 ~Matcher m = p.matcher("one cat," +
     " two cats in the yard");
" o/ ^6 Y! l  H$ d' wStringBuffer sb = new StringBuffer();
9 C6 \. w4 V* x, xboolean result = m.find();
// Loop through and create a new String
// with the replacements
/ }' R9 U3 t9 F+ p3 U6 d- c) Dwhile(result) {
5 {, J, n# ~0 n& ~- [# D$ J% Vm.appendReplacement(sb, "dog");
# M7 W2 c, I! m. wresult = m.find();
}
// Add the last segment of input to
0 H! B$ }4 K" r* j4 T& J$ Y5 R+ t// the new String
m.appendTail(sb);
$ R! l, p' U, CSystem.out.println(sb.toString());
8 x/ {% h+ D. L9 \8 M}
}

4 }; A: N) `$ W, m2 E) K2 U电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
* Checks for invalid characters
* in email addresses
/ |4 x' y2 [) x/ a& T* F*/
public class EmailValidation {
- h6 x6 S% |2 K" [public static void main(String[] args)
' Z1 I. d0 A, t4 M  P6 _           throws Exception {
           
8 `' S% j/ K5 @' A! `1 L* e' n, H' tString input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
0 H( O  s% ~. LPattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
# H! ^9 ]8 [+ C  @0 USystem.err.println("Email addresses don't start" +
         " with dots or @ signs.");
5 }" b  c9 g& ^, ?//Checks for email addresses that start with
0 D1 N0 H* y4 q/ N! B5 v' Y. s//www. and prints a message if it does.
1 W6 P  i+ J# o, D' up = Pattern.compile("^www\\.");
m = p.matcher(input);
- ]- E: i. d, Gif (m.find()) {
System.out.println("Email addresses don't start" +
. C' m" X: R+ b5 k   " with \"www.\", only web pages do.");
}
9 [0 T9 h7 j) w. I+ a) Jp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
+ b/ G8 ?% f7 DStringBuffer sb = new StringBuffer();
: T$ s8 n6 h6 L# r1 k; Y/ f- lboolean result = m.find();
boolean deletedIllegalChars = false;
4 T/ ]% Y0 |) r, u0 b
+ }  o" W) b0 i0 Bwhile(result) {
7 o9 `: H; I  Y+ ]/ X3 v$ BdeletedIllegalChars = true;
* _, q# K9 _5 z9 U0 F; V  N! ?. X2 ~) Ym.appendReplacement(sb, "");
- K5 B, b1 X2 K7 }8 n  i/ j  gresult = m.find();
  E. [* g9 @/ N6 P+ k) b, q0 G7 j}
3 \$ ~( w+ r% m# N7 S7 d7 {  Y
- l4 g2 P1 p) ^' u/ h5 b# h% k% b// Add the last segment of input to the new String
5 q* J! L. T4 u5 T% Wm.appendTail(sb);

3 [8 i6 M' d4 R7 c; e0 Minput = sb.toString();

& w# g& z' Z( D0 J# j+ f( Wif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
' [0 M% l$ ~7 d0 W       " , such as spaces or commas.");
9 [* @3 v6 X2 b. T! Y0 \7 G}
}
! e) C: H9 m+ g6 b, s}
$ w( b8 }% x4 W1 o0 o7 J
* M' ?; a+ c/ w9 n( t! m从文件中删除控制字符
( M7 ?) x* b# [8 {
# K8 ?; a. {. |4 p4 E! ?/* This class removes control characters from a named
* file.
$ p  M( W  K8 L*/
import java.util.regex.*;
" w: d3 a0 X' Y' u+ M! pimport java.io.*;
/ L- m' U4 Z8 o8 A9 I
public class Control {
  J2 s7 T; m9 _( R$ I6 \; Hpublic static void main(String[] args)
           throws Exception {
           
7 U! u& g7 f/ g. M9 P//Create a file object with the file name
& A' R$ s$ k' \2 p//in the argument:
# P% j' i1 x9 O  J9 j" V  d1 EFile fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
4 A4 D6 K2 V2 WFileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
9 d7 y  N+ v" N, E! V2 ]
BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
! f+ ~* x  {% L+ TBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
( V" m6 z# d9 V
// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
6 N" ^- \( P, j, A0 I" CMatcher m = p.matcher("");
String aLine = null;
& \0 ?) n5 P# [+ P; c4 Zwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
) _* A- V8 S* Y0 g" b- O//Replaces control characters with an empty
! F  u: `; V; u0 P2 \$ G( d' u//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
5 p) U% E; X+ Q- Z3 w" S) j}
$ ~9 t% K5 s- _3 ^in.close();
out.close();
' {, ^1 Z3 |4 u5 s1 Q, G+ |}
5 d7 n5 v0 b6 E2 d" d}

3 Q6 m4 ^0 C' m" p- v, z文件查找
1 |( {+ C. R  D, j* p2 X& d
/*
& l2 }( w& T' }0 @: j* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
$ M3 `* g% Z- C) }/ D5 Aimport java.io.*;
+ H% v6 u1 x$ r1 Iimport java.nio.*;
: W4 F3 e+ R5 m. k; m9 vimport java.nio.charset.*;
+ |( ?3 V  ^- Y" T" h* c) Z0 Qimport java.nio.channels.*;
( J+ N* j6 [( T. D3 f/ N
public class CharBufferExample {
6 |. x/ _! u4 X8 {/ u" Fpublic static void main(String[] args) throws Exception {
0 c2 L+ x0 e7 t0 J- \+ p8 Y// Create a pattern to match comments
" n- V8 c6 J+ lPattern p =
7 T# |5 n( x% J: O4 E6 X- ]Pattern.compile("//.*$", Pattern.MULTILINE);
/ l9 j+ E5 }" _! v
) L' T% M/ z- |. r8 |. i- @// Get a Channel for the source file
File f = new File("Replacement.java");
+ [/ o  q5 C  k+ [8 Q7 @FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
" Z( y- T5 O% ?5 S( t" |( ]0 A
// Get a CharBuffer from the source file
% _4 y+ M& y5 d" ?7 O( g& L5 QByteBuffer bb =
3 F) u7 {) r+ w0 `6 ?fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
; G9 T5 P9 w' H8 I! Z6 u2 rwhile (m.find())
( `, B- I9 l% gSystem.out.println("Found comment: "+m.group());
}
}

/ o5 f1 ^+ C8 `+ u0 s7 U; r  W结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

2 O) }% i& `9 v6 g$ a) h3 {, DJDK1.4之正規表示式
- G4 v' r+ ?1 \9 ^: Bwritten by william chen(06/19/2002)
1 i2 ^, W$ h5 z+ ^5 E
( i8 ^* f* g  v6 J( ^--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)
" o- c5 n% k& }4 U3 s4 x( ~
2 V8 x- ~+ P: x" n+ s2 u; w就是針對檔案、字串，透過一種很特別的表示式來作search與replace
, u+ f& w  l& G9 A' ^$ r. B7 d
  g3 k  N9 _% r因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式

4 w. k, r) _5 j" L* j" y我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
& {( y2 S  `2 ~! w
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
! z9 h5 b& t- {' p
9 Y0 e+ o, m0 p) m) k, X- }剛剛列出的一串符號" s/
* R/ }8 p5 X  w! K4 ~- E: t. C適用於j2sdk1.4的正規語法

- j: Q8 W- W" n; u( Z! e+ U"." 代表任何字元
5 v$ L  @. L- I2 v( h
正規式 原字串 符合之字串
0 K9 V2 \* {  k& J2 k$ ?: i! v2 ^; U. ab a
.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
3 J4 ?( l- k1 b  \
4 _" p- E5 U: A8 {6 S正規式 原字串 符合之字串
+ ab ab
* abc abc
$ e# s' P( Z% h! v# d
  R3 h2 A  ]* \7 K& K3 K0 ]7 Y"( )"群組

正規式 原字串 符合之字串
. Y, k3 c8 A  k: _(ab)* aabab abab

* N% d6 J: `. K' u1 W; v字元類
0 ~% |( S* R* N* F& x0 K; t
正規式 原字串 符合之字串
5 {* j" X( Z4 Y: U% P[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab
0 |" b4 R( c) s8 a; V7 a; n/ A
- P" r+ ^: M" ]: _
& R  g$ \2 A* j. H0 Z簡式
5 @1 H5 X7 b( @9 D/ H' v. y
, u3 i  G5 J0 ]- S/ l% u\d 等於 [0-9] 數字
. h2 t1 q4 T9 z\D 等於 [^0-9] 非數字
, C1 d5 b. H4 F+ \\s 等於 [ \t\n\x0B\f\r] 空白字元
! ]' u2 G% {3 p8 \\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

" M8 C- A) Z* e% v$ M2 x1 G" V每一行的開頭或結尾

6 L8 e& T& T3 O8 a" h6 g^ 表示每行的開頭
$ 表示每行的結尾
3 W/ H/ h. R8 h; c+ k1 l5 @: I0 c
. c8 p1 N) _! h' ], k3 C--------------------------------------------------------------------------------
) L: I2 F; s1 j+ y4 h+ W3 w) {
' z# o" a4 v3 _& E8 x& R正規表示式 java.util.regex 相關的類別
& V5 L0 |0 N9 z) K" {
5 ~2 a3 z: t: N9 b/ ~5 o9 RPattern—正規表示式的類別
/ u7 D; k1 k3 B( T, C5 dMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
  V7 j& V( V% n# G3 f4 d, ]  x' n/ [
範例1: 將字串中所有符合"<"的字元取代成"lt;"

  o; o% p  P$ f/ n& K8 D+ |  j6 limport java.io.*;
import java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
0 ?: L6 C$ M4 Q# _7 p; Z*/
public static void replace01(){
% R+ s6 d! P8 Y) S5 T8 w7 D# Q// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
" \5 [6 ]+ Y  S$ J9 qBufferedReader br = new BufferedReader( r );
% m2 v4 ]# ^/ m9 c2 {/ iPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
+ o/ s$ v+ t* F+ x( W7 zwhile (true) {
String line = br.readLine();
4 W9 v7 I1 z. K+ I* [! h// Null line means input is exhausted
3 \' {* s5 L( j: r$ |3 T" Zif (line==null)
# e4 x+ S1 V5 V, Gbreak;
3 p; b7 b/ G) a& D1 vMatcher a = pattern.matcher(line);
while(a.find()){
2 W' o, q' _7 i( t  v/ FSystem.out.println("搜尋到的字元是" + a.group());
6 H/ m- b* a: R4 C! r6 |+ x! d}
7 ~6 C% d& R4 E' a5 O4 [System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
, {- j2 |% a8 B8 t" W, y}catch(Exception ex){ex.printStackTrace();};
}

9 `4 w1 e, }6 Q+ B# \5 y, k範例2:
: ?  a# I2 D* E1 l
import java.io.*;
! A" H/ O" a$ Rimport java.util.regex.*;
/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
0 O1 E/ Y( n( p$ r$ `*/
public static void search01(){
// BufferedReader lets us read line-by-line
5 R5 X9 ?2 ^# `7 P2 QReader r = new InputStreamReader( System.in );
1 w+ j+ x( V% P$ vBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
" @8 g. a  T8 X" l0 U# x7 dwhile (true) {
2 g6 k9 M5 }1 K& dString line = br.readLine();
String words[] = pattern.split(line);
9 L0 l- R4 [! a, L7 b9 Y// Null line means input is exhausted
) ]8 l7 m' N4 S3 b) Jif (line==null)
* ?5 v; W4 [5 R+ i6 Kbreak;
# @, V- e1 Y0 L3 m6 \// -1 means we haven't found a word yet
7 ^  p7 |) q6 s7 yint longest=-1;
! u: W3 m3 H1 o  @: [6 a# _int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
/ k6 F* c$ C" T1 T- C4 P1 xif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
}
4 m+ @( w0 S  A; Z( h' r}
System.out.println( "長度最長為:" + words[longest] );
}
' X8 i4 {" z. {) _% h3 A3 }- x}catch(Exception ex){ex.printStackTrace();};
7 V' l  N! L* J8 }# y* b2 P6 ]# c}

--------------------------------------------------------------------------------
* g5 Q7 D6 c) L. \. ~- d9 s( B
2 v; B. O) A* m0 x8 r) Q0 u其他的正規語法
, k4 F; z7 E' O1 ]$ L
+ s7 V) w" R2 j6 e: s/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水