关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。

+ J1 B1 Q0 V; l' y2 Y( [6 a支持多种平台
! d' |) ^5 Y8 s! u5 M5 g

正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
$ ^* c) w% I0 L3 D
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
' x# L8 G& y3 N
. y% P9 d! Q6 l" [1 [) J许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

( g& E" X2 A" A比你想象的还要普通
6 L* i  t5 _# D4 \9 r随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
* m2 g- i2 e7 r9 R/ {
第二部分：
+ g) l/ s" J/ @, {9 s) r----------------------
字符匹配
+ m0 s6 |$ T( U0 o5 y. y' [
4 D2 o$ a6 S( A. A* q* p5 W正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

1 O9 v: o; m4 L! W4 O( U每一个表达式都包含需要查找的指令，如表A所示。
& x% }5 @+ d6 t
Table A: Character-matching regular expressions
格式说明：
---------------
7 e4 t+ r( k3 R* A) ?5 n- ]. y/ Q; M操作：
0 X  ]& _; q; |解释：
例子：
9 D$ w; w: A, l3 J: v, Y6 Z结果：
----------------
6 T) k& t+ B" Q.
6 L2 c7 ~7 K" J* ]Match any one character
& e  B& N, @) M. Rgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
8 t% V# ]: l, D7 r. G2 d6 O[ ]
* |0 g4 l; a* ?! t: N: X# oMatch any one character listed between the brackets
$ H3 n* g$ e: z. _grep [cng]ord sample.txt
' [- W, y9 A& S- {( S5 d6 n+ WWill match only “cord”, “nord”, and “gord”
- T0 w% @. s& O) E6 O8 g---------------------
# \) F' f/ \/ D[^ ]
Match any one character not listed between the brackets

grep [^cn]ord sample.txt
  N/ ~) ~9 _! D9 V4 y9 BWill match “lord”, “2ord”, etc. but not “cord” or “nord”
  O( d* h3 {+ B
grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
8 Z' }! S' X6 x8 [6 E* ]6 R
grep [^0-9]ord sample.txt
) x: @# Z1 Q& f" O" b0 Y/ f( `Will match “Aord”, “aord”, etc. but not “2ord”, etc.
' L- T7 H0 ~0 I6 z/ ^0 \
4 c; E. J  G+ T3 N% r; I重复操作符
8 x8 w% p3 D/ K0 L. z2 \重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

# Y8 E( l, I8 H% i) |Table B: Regular expression repetition operators
格式说明：
' Q6 S6 L; S" _- B* M---------------
操作：
解释：
例子：
结果：
- V7 f& R% b1 ^& G& \5 ?* F----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
2 q3 M) c( |. u( \, ^, l------------------
& I% b5 R$ N/ h7 \*
' M8 E( M& i, p  t% [- Z. W/ DMatch declared element multiple times, if it exists
  c% \5 r% g' T) |2 b4 k2 degrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
( i: d0 }3 s2 a4 R' K* e-------------------
7 `! A8 ]  h, d. B; c$ ?+
6 ^$ g/ F. Z' r% @* U- _Match declared element one or more times
" l$ t: J& v( Z% B% I; cegrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
( `' L3 S3 z- S( F4 A--------------------
{n}
4 v/ B0 E# V/ U/ k- QMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
9 F$ C& f, Q3 }& B& ^4 yWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
2 u4 e$ T7 t/ i* L4 x( g1 c) @------------------------
{n,}
Match declared element at least n times
/ i) t5 A/ X! x9 F4 H5 |egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
! N8 ^8 N1 u' hMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
9 i& T) x, B. [6 G3 \8 mWill match “nerd” and “neerd”
3 c' e1 T" i1 y& T; |
) @: k; H5 g& H第三部分：
1 g! J( l) a# c9 K0 N+ Q----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
9 s8 H. Q6 e& }7 Q" O2 x& {
. x" q  R1 s6 t! _% W+ B6 A' Ws/pattern_to_match/pattern_to_substitute/
8 ~( A* r. H$ {, W
% e9 f8 n4 z& ~1 [8 i
Table C: Regular expression anchors
0 k  D% a$ J2 t% H/ ?" T-------------
操作
解释
例子
结果
; w: ~+ G, `* P! `---------------
, k2 x. j0 W& z- m+ n. z1 X^
Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
4 z9 F; X2 Q. J. B---------------
$
! I) E- w# N" R, L( L; V4 eMatch at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
4 l7 x; J' o+ ^" L+ Y* w$ J---------------
6 t* a( M4 E, f3 D2 @\<
. ?" [8 S$ d1 g' u0 nMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
* o( ~$ ^* f: f\>
Match at the end of a word
4 N4 e. G. S5 W4 P% L6 X, @s/\>/blah/
4 c, J% L1 ^; w3 M: H1 `Inserts “blah” at the end of the word
8 P6 O4 B4 M+ Q! h& r' D6 B
2 Z) o/ }! D- q) H+ ~8 Y5 Q" K0 N( c! eegrep “\>blah” sample.txt
Matches “soupblah”, etc.
$ w. i1 G' H) \' v4 y2 r; g  ~2 n---------------
\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
  r* l# ?% @( Q6 \8 }* G- H/ j1 `Matches “blahcake” and “countblah”
1 f  b1 M: }% L" f# ]; `-----------------
6 z; D  f9 t+ I( i# c1 K' t1 o1 v\B
- N& d$ L! [% @# p# u. aMatch in the middle of a word
egrep “\Bblah” sample.txt
, H7 k$ a. F7 p6 B  F) \Matches “sublahper”, etc.

间隔
6 a4 E5 o" {. S/ ^3 c; E) ]
Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

- C" I7 D0 o3 ~9 ?egrep “(n|m)erd” sample.txt

# q& G/ B+ ~  \! F5 _# i# i6 U间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

9 M& k1 Z. ^9 g9 {+ @6 U/ Wegrep “[nm]erd” sample.txt
; w9 N$ }7 e/ R( e% w1 w
2 w- _4 T- ~, x& |当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
----------------
一些保留字符
2 V& l3 v- X: O. gRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

" K( ]! e( w+ I% e, m^ (carat)
. (period)
[ (left bracket}
6 |* f* w& _+ Z7 O- U9 {$ (dollar sign)
( (left parenthesis)
  R( p( e! O& m+ A$ b% c) (right parenthesis)
| (pipe)
& z" q* m7 j. }& ?# ]9 F3 J2 M* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
; j5 F% q0 Y  |6 B; [: M) x\ backslash
4 b7 G- P8 x( J: B一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
! J  M) \7 j5 b: @" j7 ?1 N* e" X- R
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
9 S, `& L; l6 ]; ^; V& c
0 j; Y2 m( C4 ~* w8 s你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
- z0 e! ~: D' _1 R5 T在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
4 \3 i4 H4 [9 u, t$ o+ `& G) _----------------------------------------
" ^/ o% N9 [" i; H正则表达式和Java编程语言
-----------------------------------------
9 J+ N7 K* G- J) F4 g( `类和方法
' U5 i8 G3 S! ^  c6 L# `% R, @' d
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

$ V9 \3 T. P) n9 [; I  e8 sPattern类
* I, ~- M, j4 V! W. F& M8 c
# F4 _% Y: B: Z0 x- a: dPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
% l9 s5 p' u1 l/ s; J! t7 F
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
, N3 `+ h& O- Q  g0 h
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
7 r. i) ]/ t! B# _% G
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
& |  i$ t# K2 e# z% N2 G- D
/ x1 |/ s5 |8 t! B' |% S/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
) N  T8 ?1 x/ H$ I% L& ~# x. cimport java.util.regex.*;
$ ?$ k$ \; \: R/ f
public class Splitter {
; O4 Q; H, [" S$ W" ~0 x1 S+ ?public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
. P, @6 k' m0 c* h0 u2 ePattern p = Pattern.compile("[,\\s]+");
2 l. w7 Q8 U- y// Split input with the pattern
, l0 n- x& I3 o6 k7 EString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
" J" ^$ G4 H- z0 O  B: B}
}
6 d: H5 J0 c+ K, t5 [* S$ `# a8 D
) V- g+ N% [1 @/ J+ S% ?9 {Matcher类

( X; M' ]# h$ O" oMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
/ M+ _7 ^8 {  I
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
, v; A1 }9 h/ p8 ]
matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
* S  ?1 v# S& A# g% c5 A! M' o  `) r
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

: o$ h+ |/ N" g! Q- d6 [* Y* SappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

2 D8 {0 A0 ]1 V4 B/ F/ I$ c7 ~例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
* \4 z; r" E+ J5 y
CharSequence接口
+ k3 S( T$ k* b# x$ Y2 R( R. K2 N
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

& U" D: _1 L2 XRegex情景范例
7 x& O& `/ V& p8 e
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换

/*
2 p5 ]) A" p* M8 h; a+ `* This code writes "One dog, two dogs in the yard."
7 i+ x0 ^# g8 ^8 v* I* Q5 r* to the standard-output stream:
' z5 N8 }, G/ Q  P4 r0 S0 y, ?* q*/
import java.util.regex.*;

public class Replacement {
0 D7 y4 `6 n; n) W, opublic static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
9 k( `) X" k) H2 R" [+ ^Pattern p = Pattern.compile("cat");
2 d3 c: J1 Y( \6 ~+ A// Create a matcher with an input string
/ O! A. _8 f$ N$ [  hMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
// with the replacements
while(result) {
, J/ S4 ^, K: G6 }* |m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
6 {" t7 {6 W& o// the new String
m.appendTail(sb);
System.out.println(sb.toString());
" [7 A6 ^# o! Y  Q}
}
: k2 U8 T1 R2 H( {
$ s4 W3 k$ b) B- X0 K电子邮件确认
$ t) i0 O* t0 E( @0 {9 u
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
$ r9 h* M1 a3 a; e! b
# t9 ]1 m; Y, f2 A. Q/*
* Checks for invalid characters
* in email addresses
& M. \1 R+ R* v# N/ }' L*/
public class EmailValidation {
public static void main(String[] args)
) n/ O/ ~4 _/ G, A2 z1 I           throws Exception {
3 w, E* y* Y" P3 ~/ A  n. _           
String input = "@sun.com";
5 x" F& h! c, f6 A8 M9 u; U//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
& `$ x. K& U- X( ?7 u0 g* _% m" {//Checks for email addresses that start with
//www. and prints a message if it does.
) p2 b: o# u! s* r7 }  r) \  ip = Pattern.compile("^www\\.");
m = p.matcher(input);
, R" {3 H, i5 ]0 Jif (m.find()) {
System.out.println("Email addresses don't start" +
# J7 {; R( V8 o3 b' g% H   " with \"www.\", only web pages do.");
! g- l: R1 G* |/ g9 z0 Y3 H; d}
  O- T# G4 y6 C1 i0 b8 op = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
: Z: ?& l$ k/ A! r: qm = p.matcher(input);
StringBuffer sb = new StringBuffer();
) C. f! T) C% F: r/ ]0 i$ U0 Y5 Wboolean result = m.find();
boolean deletedIllegalChars = false;

! e2 |8 `  u+ `: }! K0 `while(result) {
2 I+ N7 m" Q6 G( F2 {7 odeletedIllegalChars = true;
m.appendReplacement(sb, "");
% C6 h9 H' b$ E' G/ o, Kresult = m.find();
- h, l/ D' x4 y: Y. _}

// Add the last segment of input to the new String
: ^. K8 e+ e2 B: Q6 Mm.appendTail(sb);
( n0 u$ e/ u7 \
, g" }$ M% E9 A( l' Qinput = sb.toString();
; E3 {1 @# |" z4 e4 E$ r5 F
6 t* B9 h7 v, N& h1 Zif (deletedIllegalChars) {
/ ]$ T, b+ @, [5 L' ISystem.out.println("It contained incorrect characters" +
* ~% ]# I( g1 h- |9 A       " , such as spaces or commas.");
}
}
9 U0 t5 X: {5 c" r) Q}
* o: H- |# G, }4 V
: p7 N& Z6 Q: E+ p* {0 e$ F从文件中删除控制字符
) o6 w& n+ l1 L# X; ?& b
/* This class removes control characters from a named
( R, S3 @  ], D" ]; u* file.
*/
8 V9 T1 c% v" v  P7 M# R$ f) Cimport java.util.regex.*;
import java.io.*;
4 T7 W3 H/ }' _" g0 h/ ?
4 q9 r6 V  L! t! X0 @- C1 Ypublic class Control {
public static void main(String[] args)
3 h6 A7 i8 j- q' g1 w# n9 G           throws Exception {
           
//Create a file object with the file name
3 x5 Q) o& e6 Y//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
3 @4 h# e' L: H& `' }. n//Open and input and output stream
FileInputStream fis =
: l9 c+ i0 I9 _. X" x) G       new FileInputStream(fin);
FileOutputStream fos =
8 u3 @% x" L+ |: _0 E       new FileOutputStream(fout);

+ a( p0 D2 s) u' L) }" V6 ?BufferedReader in = new BufferedReader(
. y7 X0 c/ ?( G% f3 @1 c- _     new InputStreamReader(fis));
4 p9 [; A. g1 lBufferedWriter out = new BufferedWriter(
: f/ M7 p4 G- I2 p6 x) B$ W$ r     new OutputStreamWriter(fos));

% Z6 e; r6 Y  t// The pattern matches control characters
* ~/ K4 S# ~7 p7 {; g7 gPattern p = Pattern.compile("{cntrl}");
; b9 _0 ^1 Y0 m/ wMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
7 b3 U* M, D" q) {9 Z; P% _$ w4 R//Replaces control characters with an empty
: t  c' _, P7 {& F4 Y( z$ s//string.
; A7 G; ^) [7 o" ?6 n" a6 rString result = m.replaceAll("");
out.write(result);
0 X/ S5 x: M8 `% R  H3 k3 cout.newLine();
6 \# w: u) K7 g8 N8 I1 Y+ _8 }}
in.close();
) h$ H& b0 T8 Y( V& F* g- bout.close();
% z" f& Z; V' K}
}

& C$ q; D! l; B6 F, r/ o" I文件查找
5 H% g" Y4 \0 f' T& q0 W
& U7 V5 C; m* F0 b/ W/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
; y* U6 P' p! v4 U4 d# jimport java.nio.charset.*;
import java.nio.channels.*;

3 X$ W4 t# l. l" x) b! xpublic class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
& K* d* W: a% D9 M% |' lPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
" X0 ^5 E0 U/ `! H6 V6 X5 }  U
2 n7 G# V& l) ~# W// Get a Channel for the source file
8 S. o. j4 |6 ^5 ~File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
9 V; n0 W& ^+ a( Z" v. lFileChannel fc = fis.getChannel();
$ c3 {( B0 M/ R
// Get a CharBuffer from the source file
: b* v+ `1 S" @. LByteBuffer bb =
( G/ }+ r5 Z) Xfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
: j3 a6 _' S4 VCharset cs = Charset.forName("8859_1");
8 z3 [* O1 B' pCharsetDecoder cd = cs.newDecoder();
" \7 h$ k$ [7 m# F; Q; |  dCharBuffer cb = cd.decode(bb);
7 l# ]; l9 }; A8 M2 t( r6 G
// Run some matches
Matcher m = p.matcher(cb);
5 \. Q& O! J6 g" x' X0 |$ y6 bwhile (m.find())
' B$ {; b" U# P) C" t" H  QSystem.out.println("Found comment: "+m.group());
  ~; s/ d6 w2 [' v}
0 S- H6 g; |' u) w1 ^0 I. Z% z! x+ e}

/ D9 a& }8 J0 E结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
* ^* v5 }$ T% v
JDK1.4之正規表示式
* X# F3 N  @8 N3 ]& ?9 Vwritten by william chen(06/19/2002)
% T! s% z. I3 \0 l7 H6 @2 z0 o, U
# a3 k6 A- a3 E1 v! ^: U) I--------------------------------------------------------------------------------
4 d* B0 W3 c. Q8 @# a( X$ u0 G$ z
什麼是正規表示式呢(Reqular Expressions)

就是針對檔案、字串，透過一種很特別的表示式來作search與replace
6 @5 C: t. U6 Q2 Z% @
' U' s" u  ]( G  y- T$ b9 l1 @因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

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

3 u9 ?6 D( {/ i- h3 x/ I我們可以很簡單的用 "s/
& D7 B! P( {4 X# U因此jdk1.4提供了一組正規表示式的package供大家使用

' I/ q# V% P' ^8 z# X若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
5 y2 ^$ \0 w8 V6 A8 w
剛剛列出的一串符號" s/
( d: ^9 M! u% x7 O. n# v: h0 A適用於j2sdk1.4的正規語法
! x$ J* Z, h8 j) [7 [5 Q
! P1 N6 Y0 V" P"." 代表任何字元
" P( n$ W0 v3 G5 f- L5 Z3 V
5 l% d4 w7 M* {) O  e) m正規式 原字串 符合之字串
  Z0 ^3 Y2 t$ \' {. ab a
.. abc ab
3 s( Q* i2 h& S( c# G* e/ ~1 R
* I" \6 Z9 z6 R3 C) t"+" 代表一個或以個以上的字元
) G# y7 b6 @1 F* y6 |( }5 f: Q"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
# r6 o7 c2 b/ U& n0 W! \2 W  f+ ab ab
" K% ?6 v2 o1 Q& r% |* abc abc

"( )"群組

+ Z. u1 K$ U  r; ]- E/ q) i正規式 原字串 符合之字串
6 y" m% C% p' E3 v' v% R& v(ab)* aabab abab

字元類
! F  y# m; A+ K" ~& p
: U0 u$ h' S; ]正規式 原字串 符合之字串
8 l2 W3 T: \4 B' ?$ _# t[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
" `- ?& C9 Z' Z0 H6 t* x  Z2 w[a-d]* abcdefgh abab
0 Z, k% r% A8 N; k4 T  g9 \: D
8 e/ h; Z! a5 ]; x
( u+ ?0 z! K2 @1 t" |, e# _4 O簡式

7 N2 `9 k8 a" A1 p\d 等於 [0-9] 數字
; v' w' T# q) u  P# E\D 等於 [^0-9] 非數字
. Y! N% e8 R- Z\s 等於 [ \t\n\x0B\f\r] 空白字元
7 g* Q. U( |* Z9 @% ]0 N, m\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
5 r9 g4 i7 z7 H/ S\W 等於 [^a-zA-Z_0-9] 非數字與英文字
/ ~! }% G1 _; e$ V  ]- @/ x
6 R5 Y- B) @3 Q6 W5 Q1 N每一行的開頭或結尾

; g- ?" C/ B8 n^ 表示每行的開頭
$ 表示每行的結尾
! u  k" @$ M8 E, Y& X, _8 K3 @
  W8 V! W! j4 u8 y" l--------------------------------------------------------------------------------

* ~- j3 f! C' Y. M正規表示式 java.util.regex 相關的類別
7 [# |: X: s# o% L
Pattern—正規表示式的類別
% ?  U8 ?( U  U( {9 I2 N# d( iMatcher—經過正規化的結果
: E- Y0 f( c% T/ @PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

範例1: 將字串中所有符合"<"的字元取代成"lt;"
% n  _2 ]7 e9 f, F! j; u7 ]9 L) b
/ a( X6 {$ a0 ~" Eimport java.io.*;
import java.util.regex.*;
/**
& v' @( \6 G* ^' S6 ^: ]0 @) l* b/ [4 _* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
// BufferedReader lets us read line-by-line
/ d4 X' _# W  qReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
  f: o  K5 j; A; nPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
String line = br.readLine();
// Null line means input is exhausted
  u6 u$ G+ I& ]1 `. gif (line==null)
( ~0 o% m* n2 T4 \! g9 jbreak;
Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
3 v. t( {! `; h/ w; j" q, S}
- m, z) R, R5 Y8 t" H2 _$ Q
範例2:

. p& w- U$ A) j4 r, cimport java.io.*;
import java.util.regex.*;
, X0 ]- b6 S$ Z6 i' }. t: R/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
* g1 f! _. v7 \/ m4 @' ^' p*/
public static void search01(){
. t) ^. P# P9 f6 q9 C5 `. A8 z" B$ B// BufferedReader lets us read line-by-line
9 H7 r/ S. F2 D8 ^) I  {2 B( zReader r = new InputStreamReader( System.in );
" ~2 }1 |6 |/ E: H5 OBufferedReader br = new BufferedReader( r );
8 h: G- h' i, Y' RPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
$ u# V' }0 j# h8 p6 Q% Ywhile (true) {
3 w* x# k8 ^% h9 eString line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
0 {# s/ @% U! \! t& ]  Bint longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
/ ^1 F5 p; ]2 |3 lif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
. B3 t4 \5 r- S- d}
}
System.out.println( "長度最長為:" + words[longest] );
; X* P1 d( D8 d}
}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------
3 B: t) O  z) ?. V& O- y9 P/ Y7 r
其他的正規語法

  ~( b; R3 T7 G4 {3 K) F* n/^\s* # 忽略每行開始的空白字元
, m6 J- b2 b$ H' w  ~(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水