关于正则表达式---ZT

Longe

第一部分：
1 j1 O7 q3 B! L# M/ s5 m4 g; J-----------------
0 ~9 {4 z% O0 J1 L$ ]+ w正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。

支持多种平台
. Z! f5 J- X  Y$ W# T! x! E1 A$ K( F
- Y% p# H. Y9 G: t+ A/ g
+ [( w& P4 V+ f: q+ Y, q正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

& s1 D" b, a4 N4 {  i/ f正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
: }+ t* x9 x3 Z4 K5 k
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
9 L: ~/ o% U% e4 n7 A
$ K$ \) q9 y; e比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
! B8 q6 w$ f+ ~0 Y: S2 ^  g* z
正则表达式101
2 k2 `9 f. ^$ k8 Q7 d" t4 v很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
# U4 ~. U  Z% Q1 c! h% v9 H
第二部分：
5 o- l- J. J5 H0 ^----------------------
字符匹配
" B, @- V0 \7 R5 @
  G8 n7 w2 F+ s- q& \) R$ x正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

6 d' n. ?: p6 m; j* a6 f. D每一个表达式都包含需要查找的指令，如表A所示。
+ o, g# M& i, w+ \  Q0 @
) B; f  u' S% n5 z- \. w. b1 g( |Table A: Character-matching regular expressions
, W: E5 B: B4 t& K- A; C2 r  H格式说明：
$ ]* N; X. ^# {; K% y8 E, w8 p% V---------------
6 [4 i: C2 d2 E2 r操作：
3 C# J' D" O+ ~3 A  f解释：
- @1 F1 g) u0 V例子：
结果：
3 }5 d4 m' h9 \" J: w----------------
0 ?0 I3 i0 _6 b& m8 M( z.
  r! q& `9 ]7 h8 T' bMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
, Y" t! d6 x: U, M-----------------
[ ]
Match any one character listed between the brackets
grep [cng]ord sample.txt
. ^* b* ?/ D& p- h) q* `1 K8 GWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
Match any one character not listed between the brackets
  J. b. D# {# z! J5 S  R
grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

6 M& y9 P2 J1 ?, R5 p) K. F! cgrep [a-zA-Z]ord sample.txt
7 A; M% |) g6 Q5 M3 L5 _& bWill match “aord”, “bord”, “Aord”, “Bord”, etc.
/ E! S4 L2 X0 w, ^. H7 s
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
+ A  i5 l4 w3 Z
: w5 K* `) x( A! U! F0 v/ w重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
---------------
! ^( @- u9 m/ s0 Y% D- ]$ N, |操作：
/ H2 w' W- G. W# a. u解释：
, K! U& M, F9 Z5 M1 Q) C例子：
$ M% {# B" s4 r. W1 `) G结果：
" H. u+ h4 \! {( g) `3 d$ M----------------
5 h' o8 B- d2 o/ b) `?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
7 H+ k  V' U/ p& l* d6 D% i2 D3 R------------------
*
Match declared element multiple times, if it exists
, e; {7 }! z0 T. D& Fegrep “n.*rd” sample.txt
" c5 H4 k3 |$ P1 R3 S: WWill match “nerd”, “nrd”, “neard”, etc.
4 E/ r# W2 d8 _5 u-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
9 h- U; R" j: P( Z( bWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
Match declared element exactly n times
  I1 [1 a) z6 m0 J. Z1 cegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
9 @  E" H$ \  t6 V------------------------
" P; h# Q/ ?+ e8 q0 S. I+ W+ S. m{n,}
$ m# c+ O1 W* U5 PMatch declared element at least n times
* |, Y; P0 E0 _$ z3 M4 }egrep “.{2,}erd” sample.txt
- m. R) a. W6 ^" p1 j3 f( H) TWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
# O: p- w, I: w  Y6 ~* vMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
/ Q* n) z; u8 N! a/ jWill match “nerd” and “neerd”
; q+ l6 |2 J/ L
: b& w: q8 n( b6 Y" g第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

8 A3 a) @! p! ]% Ss/pattern_to_match/pattern_to_substitute/
: b( z0 E4 y  X2 I* r4 \) `9 X. x

  M& [0 U" i- O9 C  h) t/ n+ ]' d) zTable C: Regular expression anchors
8 F  S) S6 T4 I  e-------------
& U, U- V* o$ |: m7 a/ l操作
解释
) V# k" K3 R( n% o5 q例子
! e# X0 O+ n! k  s结果
% D( c0 H7 z: N) L0 ^0 Y+ X2 z' c---------------
4 n, e/ j5 p: M4 M; c5 T^
. g$ a% N# m. d3 I: h5 H# ~$ dMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
. ]5 L% _# G' q! Y& w* \3 r9 ]---------------
+ A5 {* N+ U9 Q( }& C$
Match at the end of a line
s/$/ blah/
% ?4 r  `( S( R1 sInserts “ blah” at the end of the line
7 X4 V' [' ~" W" t/ e---------------
/ d9 b* j; \- L\<
% h9 N9 ~+ t' z1 \Match at the beginning of a word
+ m1 m0 Q; E5 X: `; }8 v$ t/ a0 Ls/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
) r8 ]0 g1 N0 u* N8 S( C\>
5 j1 ~, x( j4 T! _6 t/ }& rMatch at the end of a word
+ s8 h# ]+ w3 fs/\>/blah/
( S3 o3 X7 O2 Y0 \# w( H, hInserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
# P; G9 F, u: B- \; \6 X---------------
: p/ E0 _4 m4 O\b
& G) r( ~8 p4 I: B9 C0 K4 }; hMatch at the beginning or end of a word
4 f2 x1 q) Q" N: ?9 ^egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
2 P$ i8 P. n; e' q' D\B
6 A+ S3 b+ @- C- Z# t  o& aMatch in the middle of a word
* _) [! A* v  l4 Y7 Negrep “\Bblah” sample.txt
3 i/ {. S! V, x' gMatches “sublahper”, etc.

间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
( t8 b/ _8 i9 U' H* g
- L8 }6 q7 i& y1 J" [2 Xegrep “(n|m)erd” sample.txt
! v8 R* T6 `) {1 d. R0 W1 b% t
" r; G; U  o  n6 ?8 M- V间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
' N' O8 Q8 c; {3 q- P
3 j( K+ @7 u! g) \7 J* ?egrep “[nm]erd” sample.txt

; U9 E* Z/ b6 V! z# t* _) q2 t9 Z! r当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
2 T& X5 A$ h9 W+ x" J
第四部分：
" y' y  b6 J' a6 _* z# M! f----------------
+ B, d8 q0 L) U3 ]8 i3 G7 F一些保留字符
4 \6 Q$ o1 y" t7 O$ _3 |1 f7 TRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
- t& }9 i7 Z, X0 d) w( x  w$ V
^ (carat)
4 w( Z) P! |5 I' f! T. (period)
[ (left bracket}
2 \+ O4 u! j' u$ (dollar sign)
$ f$ j; Z' X4 o' O  U% q- a; I( N( (left parenthesis)
) (right parenthesis)
, ^9 r- J' Q( H| (pipe)
5 w! J6 x( ?! `. ^' T/ ?* (asterisk)
+ (plus symbol)
? (question mark)
1 l: U% [& }4 x1 p0 L% G{ (left curly bracket, or left brace)
\ backslash
6 m3 D6 _; c. s% S5 J6 p9 z5 P* Z一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

, Q0 W2 c$ A4 @你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
6 H( K4 `. w, U; r4 o0 r# ^' K
总结
7 k  c& {, A* D; s4 H6 Z5 r在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
, n: ^& h8 B4 x8 _" x. `/ Y) T! E
另外一篇文章
& _$ ?  V. y) X----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
' U7 t/ q; N2 v4 R类和方法

下面的类根据正则表达式指定的模式，与字符序列进行匹配。
( H# r. o" D+ ?# f/ [
Pattern类

( S% T0 b+ y1 v0 u/ a$ v+ o1 gPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
6 K1 `* K; p- F: s7 k
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
; f. X' q, |# A% l" u0 l
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
+ h' j. P  r. V: z& s  u
$ S( J& Z& f/ w* N* W7 |split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

8 G. I( _& h5 q7 ~4 s: E8 @. Z: M/*
  }% P5 U" [, Y2 E* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

public class Splitter {
( j* B6 A% r* `; wpublic static void main(String[] args) throws Exception {
9 h4 p+ W; h) }" v' ^5 q# s% Y, ^$ Q// Create a pattern to match breaks
/ d' l, X2 Q# K0 @$ F  W, r/ `Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
$ L5 ^" Z8 v; v' U7 PString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
8 P+ z0 O( E$ ~7 A1 a3 X}

Matcher类
, `' K, y9 d! m8 K
) h, Y! A/ I. x8 lMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
  r1 E: ?$ I2 |* @, N% y
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
  O8 q' a6 J) i8 D  p9 e
matches方法试图根据此模式，对整个输入序列进行匹配。
( n% N9 D" r9 ?* ]: klookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
9 j7 w9 @2 G  q( bfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

* e* Q% U6 a3 W' A, t0 \这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
, o3 `8 f' t! O
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
$ O0 _7 g+ X- s/ G7 w9 W+ y+ W
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
# q; W1 v* V% _1 W) v) y, e& _
CharSequence接口
, I! Y, @; O3 u3 I
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

( f* z7 C$ f8 A1 V7 j# VRegex情景范例

7 o5 t4 Q. z# [9 J* s0 @- B1 l以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
$ W  d6 {; X- n; w- \
/*
* This code writes "One dog, two dogs in the yard."
* q. o1 y+ q" `4 ]# O* to the standard-output stream:
*/
: h' }$ A( s, {+ `; wimport java.util.regex.*;

public class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
3 o* y) R! @* j7 y7 R; r3 PPattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
, n, A- z$ a2 p2 N     " two cats in the yard");
StringBuffer sb = new StringBuffer();
& b% i" q4 a; M4 V! Iboolean result = m.find();
// Loop through and create a new String
// with the replacements
while(result) {
% L8 m, D: G5 p  y. mm.appendReplacement(sb, "dog");
result = m.find();
4 _$ g% y) r8 ^9 {7 I6 z}
// Add the last segment of input to
& g4 O6 _: ~" C2 J% `// the new String
$ l3 w% `; \. w" ?) A; Cm.appendTail(sb);
" `+ G' q; J$ S1 ZSystem.out.println(sb.toString());
}
: _2 I* q6 Z- ?! S}

电子邮件确认

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

/*
( D0 ?4 p- R' E: `  b. \3 Y* Checks for invalid characters
% m! \/ _! O( A  T! l. l! j* in email addresses
2 s/ ^& f0 y+ l7 l*/
$ r5 X' d( I7 N' r: U" kpublic class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
! S/ F8 Q3 ?& B/ c% ?- |" {: L//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
7 i4 I, C# h# Q5 v+ APattern p = Pattern.compile("^\\.|^\\@");
6 `7 {5 {% y# z; t& `8 f$ x& pMatcher m = p.matcher(input);
if (m.find())
2 j: Z4 ^+ Q" f3 W/ iSystem.err.println("Email addresses don't start" +
# Z+ l' r. [' x         " with dots or @ signs.");
9 r& a5 p' V% A, G. @: a* o  [+ ]//Checks for email addresses that start with
! e8 z# D, b! z. N//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
9 p1 S$ X" L. E, v* M5 F5 p2 ]6 Vm = p.matcher(input);
if (m.find()) {
3 D) {2 H7 n6 ]8 ESystem.out.println("Email addresses don't start" +
8 D: b- o$ `* c9 _* B   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
8 l, B( V) f5 a" [" a  ~boolean deletedIllegalChars = false;
7 _8 O5 h6 Y* f  \* _9 e5 K9 Y/ D
5 i; y. d6 X: B7 ]$ C+ _1 fwhile(result) {
( K$ b: n1 q5 M1 g* ZdeletedIllegalChars = true;
1 {  B9 }: H2 C& G3 \m.appendReplacement(sb, "");
" C4 Q; P4 e' b, z# m, Q# f" J) }result = m.find();
. X, f; ^* ]" L/ \: X0 h7 s+ \2 f}

) P. f7 K: J" K; I& a// Add the last segment of input to the new String
9 y9 W& {4 I' e8 L7 Fm.appendTail(sb);
& i$ g8 ~( @4 h0 w% u
  d; ?- U; j4 d% y) H# c! P$ winput = sb.toString();

! w3 _, s$ r7 H, I9 A# @& E  h6 Cif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
  L, {% a1 n5 S" z" j+ U}
& r: ?  S3 Z& b5 T* Z}
}

8 w8 S7 x" Z2 s从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
) g- b& k1 m" Z5 _0 P3 @import java.io.*;

public class Control {
public static void main(String[] args)
           throws Exception {
+ u7 F% e" }) q9 T$ V9 }  C           
; u0 |$ ~/ D4 O//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
3 `2 q  h- G% s" t# k$ w" j
BufferedReader in = new BufferedReader(
% R2 l4 ?2 Y/ b     new InputStreamReader(fis));
! h: W$ y/ r% |9 lBufferedWriter out = new BufferedWriter(
; O) F( r/ j$ A% \$ t     new OutputStreamWriter(fos));
8 P# D, P7 _0 g9 j" o' I5 M
% ~! Z8 z0 d* q/ J// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
$ E8 Z; m2 C( K4 ~String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
$ V! b7 D7 Z4 H) g& F7 H9 N5 v4 P//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
/ N; n% x4 F) eout.write(result);
out.newLine();
}
in.close();
) n! o- |; ^2 y: ~" X0 m# {out.close();
}
- ~4 j# G2 M1 v; o, j9 {6 n}

: X$ o/ h4 x" c. ]文件查找

/*
+ u! O# r( r& F: ]* Prints out the comments found in a .java file.
/ J# j8 n. W, |$ {*/
import java.util.regex.*;
2 s; @" U1 S7 ^3 Z& u* Wimport java.io.*;
+ L! y. i( ^- W( ]import java.nio.*;
4 \% @) C% J8 U+ k8 J6 A8 z- ?import java.nio.charset.*;
import java.nio.channels.*;

' ]! H+ Z3 K. i3 A) ypublic class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
5 k8 r0 c9 e7 O, dPattern p =
" L$ I/ x. R; F( c' z2 U6 C# bPattern.compile("//.*$", Pattern.MULTILINE);
; s" ^( ?  h- e3 M+ [
// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

1 r% _# I. O: U// Get a CharBuffer from the source file
ByteBuffer bb =
7 A9 D6 x9 L8 _- c) E0 |5 zfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
$ U% s# i) P% O+ O2 T1 yCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
$ n- |1 W) i/ W( ?5 O) ?
" \4 ^8 _  I' C$ j3 a// Run some matches
Matcher m = p.matcher(cb);
* D2 H/ K, A2 swhile (m.find())
System.out.println("Found comment: "+m.group());
}
}
. \5 k: G$ p8 B+ [9 S
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
) i, x$ h2 u7 @# r4 s6 ~% A
$ \/ p" E  q" S6 t" X6 f5 fJDK1.4之正規表示式
; A4 O  l) b6 x9 l+ lwritten by william chen(06/19/2002)
1 g8 M7 w* N* G) i/ ^5 R/ R( m
--------------------------------------------------------------------------------

/ v- S: F9 K# i' L9 ]' t, |0 {1 F! X什麼是正規表示式呢(Reqular Expressions)
5 C, W. J) |4 m
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
/ U5 e8 n* |1 D( B1 ^$ O; V
) c' _; n& l% T$ C( J0 R4 m因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

: h1 r. Q2 Q* \- }% @: g) v" \所以發展出一種特殊的命令叫做正規表示式

* o/ p# P9 l$ B1 s, |5 o我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
& W& P) j8 y. }; r8 J9 d
# S/ m. Q, m  C剛剛列出的一串符號" s/
. q7 G- @+ ]% s3 j1 ]  W適用於j2sdk1.4的正規語法

"." 代表任何字元

: ~( `: |$ b, c+ k- y9 N正規式 原字串 符合之字串
. ab a
# ?% b5 t/ E3 b7 ?1 |.. abc ab
0 b% N4 ~* Z( q' B
0 n: ^& {# u) b9 C2 t: z1 H"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
8 a% Z- {. Q* B9 O
. v* v% {8 l' G, Q正規式 原字串 符合之字串
& _) T6 c7 ?' j! W' C+ ab ab
* abc abc

* l% Z; r5 p6 }- ^, ^"( )"群組
3 |8 L3 t) v' d" I5 X& `1 Y
: G! K  g8 F8 K9 S! J& F: E正規式 原字串 符合之字串
8 |) S7 O/ Q' e1 Z; O(ab)* aabab abab
4 A  a6 ^, L7 `- d
字元類

8 h& r* S: R0 j1 X5 [/ v% P正規式 原字串 符合之字串
# S+ Z* m4 S8 W" k6 R; b  E[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
/ k/ j! D  ]+ v6 f2 Y" G( P) ~$ a[a-d]* abcdefgh abab
: B' f) \+ P5 x% T  O2 N# n. j' f
: J" d3 f. X5 c' K0 r5 Y  g
簡式

- y; ]  Z- b9 l8 U5 N, d9 ^\d 等於 [0-9] 數字
- W4 }5 P/ _5 p  o7 G\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
2 Z% C% K0 v! f' [, z$ c7 b' B8 w\W 等於 [^a-zA-Z_0-9] 非數字與英文字
  r( M' j. ?% u6 n( l
0 }9 p6 s" h. }# e1 K* n* K/ H% o8 a每一行的開頭或結尾
; x# M& z5 ~" V4 p; I
^ 表示每行的開頭
$ 表示每行的結尾
% l8 ?4 \- k$ M$ E1 ^
* n4 a2 w5 y; }! T--------------------------------------------------------------------------------

8 r3 K2 L9 u$ d; R, [* R正規表示式 java.util.regex 相關的類別

* b1 s+ h1 S3 L9 S+ d( ZPattern—正規表示式的類別
Matcher—經過正規化的結果
/ A- ?+ V+ F. E2 L& NPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
& Y- [0 F' O0 T+ Q
! T# P% ^3 {2 t  V  T0 U6 r! P範例1: 將字串中所有符合"<"的字元取代成"lt;"
5 A6 V. T7 a/ ?4 ~
# U( N1 l  v+ t! t8 i2 X6 K/ ^import java.io.*;
import java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
+ n0 y9 L* C# x6 ^& Q*/
7 d0 w/ P! o7 X1 P. s# p1 mpublic static void replace01(){
/ ]% ^7 S( E1 K$ J. }! q! }// BufferedReader lets us read line-by-line
* e  P( _, E, OReader r = new InputStreamReader( System.in );
: E. ~- E! y9 i' jBufferedReader br = new BufferedReader( r );
9 r9 r( y* y/ a) g. C1 TPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
9 {$ e9 {* H% S5 p$ EString line = br.readLine();
// Null line means input is exhausted
if (line==null)
% J3 g$ ]' N$ y7 m- v0 e$ U% Ybreak;
Matcher a = pattern.matcher(line);
8 @; f3 c: U: Hwhile(a.find()){
# f. x$ {7 \/ e% \4 ASystem.out.println("搜尋到的字元是" + a.group());
}
! Z% G. I2 r  I1 Y7 W9 ~- eSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
8 B9 e0 d: ?) S- M0 F0 R}
: o  Z8 y6 f+ t1 c}catch(Exception ex){ex.printStackTrace();};
}

範例2:
  l7 Y  A) V0 G. \. m5 R/ a
; o1 ]& d4 H6 c# m+ Dimport java.io.*;
1 l3 f. c6 H/ _3 Ximport java.util.regex.*;
/**
' Z; w+ ]9 L0 S, o* 類似StringTokenizer的功能
1 q/ {' Z# C/ t! `( x+ k; U* 將字串以","分隔然後比對哪個token最長
3 _/ ^. w9 P( f+ F  t*/
. b) U+ ~6 O9 ]( N1 S, Z' `public static void search01(){
$ |" z- O) b2 w8 X// BufferedReader lets us read line-by-line
; k, E" P0 ~' A# TReader r = new InputStreamReader( System.in );
, ?6 O. E  T5 w9 p1 W; O& n0 KBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
1 C* [- I+ H- z9 o. itry{
/ }7 u: h6 ^3 U' d+ xwhile (true) {
" |/ ^+ a  O3 y' @8 d/ H% eString line = br.readLine();
( b7 o# @6 C$ E7 ?' ^% kString words[] = pattern.split(line);
" _0 {$ B* I5 u" q. E; p// Null line means input is exhausted
if (line==null)
+ w7 ?; U* ~( k2 h% N8 u* `2 gbreak;
+ ~- [9 D; ~; R// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
7 n9 p! y, J( L1 _( lif (words.length() > longestLength) {
longest = i;
- T2 [% T6 W- mlongestLength = words.length();
; A+ ]7 u2 L/ X+ @}
7 ]9 e  F5 _' o/ J1 o3 Z* J$ d}
, u, L, g- E6 s2 r: ~9 F% SSystem.out.println( "長度最長為:" + words[longest] );
7 D/ |( {* m0 k2 d9 x}
}catch(Exception ex){ex.printStackTrace();};
. O! x' `& I6 l# R; `, y. R/ g}

--------------------------------------------------------------------------------
. ~5 v- a' \$ M) ?% c4 q" v
5 L& }& X' ^% K+ B0 B' a# _6 \其他的正規語法

/^\s* # 忽略每行開始的空白字元
& v  u8 H% @3 t- j2 Y! W: C2 X(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水