关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
, ~7 @3 d1 v3 \- a! s
5 X. P+ h! b2 \" n$ I$ `  Y) ]支持多种平台


7 Z9 S/ ]+ t! T! E' g正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

# w" R, b; D& V; i+ o/ b正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
& O" s$ H# I6 O5 E# u
) N4 s# L) N' D4 s: k/ w5 X许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

7 X1 l- B. R9 X) z  B, {比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
/ P' F6 V, {, E" S4 P
正则表达式101
1 F# _- M" K" ?# h' H7 ?6 L很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
$ h7 J" q9 [1 h1 M
第二部分：
----------------------
1 o* }7 T. R0 z字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
. M5 D% ]; l, @# e
; {1 _1 O' |/ p9 V4 G  M4 E每一个表达式都包含需要查找的指令，如表A所示。

% a' K/ z* N$ b& k. hTable A: Character-matching regular expressions
$ k5 C6 m/ C: H2 R, k: w格式说明：
---------------
操作：
) s9 B3 a; k+ D! @7 ]7 n( n2 a解释：
( r7 U+ _: R) |5 H4 ?. f例子：
结果：
% `; c/ m8 g3 B4 w1 a, W----------------
.
Match any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
" {5 q% l; F/ ]5 t-----------------
[ ]
Match any one character listed between the brackets
3 s  ]4 S; R$ j% r; V* |grep [cng]ord sample.txt
. N: v) X" U( w% t7 OWill match only “cord”, “nord”, and “gord”
& F- c/ V! P7 e---------------------
[^ ]
( ]$ @$ }& J/ B; G. SMatch any one character not listed between the brackets

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
3 O/ u$ k8 @" p2 r
% [& n0 Y; {) l8 ngrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

* ~$ ~! G: E! [( S$ m- Fgrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
: p( [8 Y  \+ t' K0 \
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

: o3 O7 \0 l, z% S! C  \3 P& sTable B: Regular expression repetition operators
5 g: |/ `5 l- Y& q0 E$ K格式说明：
---------------
操作：
) L6 r: C* y. U! h! l% q) U; {, M' `解释：
" B2 y$ J0 R' }. o1 [5 R例子：
" ~- K: Z- R" e5 P' G结果：
" v- `4 R4 z/ C----------------
9 B6 A7 J$ ~' X  i/ a' t) w$ k?
8 @; l3 G) \+ p- d# c# A- B$ L% VMatch any character one time, if it exists
) E+ D- m% B/ L; Q3 W- n# Y# b4 Tegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
*
Match declared element multiple times, if it exists
+ n! ]. E" n# ?egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
8 |$ u. b+ D, Q' {7 r. y-------------------
+
Match declared element one or more times
/ t6 H$ \: i. p, V+ E0 h! Segrep “[n]+erd” sample.txt
- G% ~% `0 o9 x9 v$ Y8 D! ^# p* E5 JWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
Match declared element exactly n times
+ S4 t1 j! [, w* Y' Degrep “[a-z]{2}erd” sample.txt
& ]# H& s. I& X- CWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
" Q4 x6 e! ^. ~+ c/ P$ @{n,}
( k7 F+ e' G2 I+ F" wMatch declared element at least n times
3 _/ s7 C1 h, R, t2 Y0 s' A% k- Segrep “.{2,}erd” sample.txt
6 k" D0 e& ~+ o9 i& o8 e- B1 p/ S2 @Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
Match declared element at least n times, but not more than N times
/ r1 \4 h, \9 Megrep “n[e]{1,2}rd” sample.txt
( ^& ]; ^7 Q, Q% DWill match “nerd” and “neerd”

第三部分：
----------------
! t+ f1 [0 I" O$ F( F* ~锚
+ p$ T  ?# {  J- k) e锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
0 N9 j/ \+ ?7 b) B% J
' e; o+ _; y* H, b# Os/pattern_to_match/pattern_to_substitute/

8 S+ k( ]9 A! J: [2 B# I) F
Table C: Regular expression anchors
-------------
操作
解释
例子
9 U* _5 g1 x% a: w. D, F! h结果
---------------
, h4 `" t- b9 Q% V9 p+ O- m^
6 E2 \: ~" ?5 J: q" Y$ [5 C& _: ]5 g& p: A6 oMatch at the beginning of a line
s/^/blah /
# f) `7 j) F* [0 M# KInserts “blah “ at the beginning of the line
---------------
4 D) U( ]! H; n$ X3 w$
, Y7 u; k) n6 V( f* l, V, c- l( TMatch at the end of a line
% `( R1 O. M4 K9 \, h- Bs/$/ blah/
Inserts “ blah” at the end of the line
---------------
+ r6 T% P3 n5 B" T) [' ]2 F\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
9 ~) H" \" }  V2 r9 n; h' ^6 B0 d
0 P+ R# l3 d* _- P3 v: y% Z! p7 S6 n3 ?4 ~egrep “\Matches “blahfield”, etc.
) I, s' d6 \* `* H3 ~1 f------------------
- Y( C( }* W8 y* q2 e, s' q; C5 N\>
7 P: }. f& ?8 J) W# K! s3 [+ ?Match at the end of a word
1 J9 h6 j* N3 N/ B, s7 Gs/\>/blah/
$ X1 N: B& n% n: U, A& b3 ^Inserts “blah” at the end of the word
* o' ~$ E) ]4 J
' |) j% @% ^$ u8 M5 pegrep “\>blah” sample.txt
" ~9 M6 _, D8 r* QMatches “soupblah”, etc.
8 s% a- H: R' k" w% J! c" K---------------
\b
Match at the beginning or end of a word
2 d0 l9 ]" |3 o; X' J8 s. jegrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
5 T2 Z& b8 M6 i- Z\B
Match in the middle of a word
' D3 j5 T5 T6 j- G8 a% m3 Hegrep “\Bblah” sample.txt
Matches “sublahper”, etc.
4 T7 C9 Z, Q( `4 b3 O
间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
$ L- G0 a* A2 ]: k6 b; M% w8 y' T
6 [, O& h9 T+ r, ^8 y1 Degrep “(n|m)erd” sample.txt
7 {' u, e4 L( S. s' }% z6 ~+ d6 v  X
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
  j6 F; c9 {# I
egrep “[nm]erd” sample.txt
7 ^$ V1 c5 a8 T1 b2 x8 A4 d
+ ]6 Z" |7 `6 o) ?当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

! E% W! s4 @0 u7 M3 V第四部分：
0 O) N3 C$ i$ e8 D/ C3 j----------------
3 K9 J+ R  U$ K; H0 r* m: U一些保留字符
. b. e+ \" S0 w- ~9 N% iRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
. (period)
* F% j; X5 k! H[ (left bracket}
$ (dollar sign)
/ z8 g2 W* I- `& d% I( d( (left parenthesis)
: |0 c0 K% o3 g+ G* }/ L* `) (right parenthesis)
4 m% E0 y( L' o7 M/ x| (pipe)
3 I6 |; ?: y( h4 G4 @- U, c& j* (asterisk)
+ (plus symbol)
: l+ g: ^( M5 A4 z1 H+ Y? (question mark)
) T. ~- \# D2 C3 H& W{ (left curly bracket, or left brace)
9 p7 ?: x% m. W  C9 |4 J\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
: W$ v" m' R1 e: f  E8 |
" ]/ f8 u7 f; `+ Leregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
8 ], G& Z, U# f
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
6 l9 b- F" |" k# v/ c在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

6 T5 j2 u  H/ s; B另外一篇文章
----------------------------------------
& C/ U! ?! O2 K9 W正则表达式和Java编程语言
-----------------------------------------
类和方法
0 ^/ A- S6 {* }/ _. k2 q
: C% G6 j( w! h9 K, A2 T下面的类根据正则表达式指定的模式，与字符序列进行匹配。

6 s( ?9 t( z% d1 n/ H$ ?3 h* |: a1 gPattern类
+ n- O+ ]8 C8 U: ?1 t( m( P: A
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
; l# H5 A5 H  h3 N) a
  o3 [. W# `9 k4 h+ {/*
  X8 T5 O# _& \- v/ ^: u* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

. [6 _6 D4 C% d! l% Q9 v4 zpublic class Splitter {
, o# A4 ]/ [9 f" a1 [. C  N5 wpublic static void main(String[] args) throws Exception {
/ K: W) A( O5 q7 {) H// Create a pattern to match breaks
/ ~+ v. @% M' [$ MPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
3 ]: r" w! |* G, U  z4 V  ~. t, EString[] result =
   p.split("one,two, three four , five");
+ I% }9 x: @/ |7 `for (int i=0; iSystem.out.println(result);
}
: i# _2 X8 w2 K" D}

Matcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
6 L8 J( H, W1 i+ Y) N
: W. H, C5 K( H; z8 c* j通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
4 o! A6 T3 C5 }! Q: c
2 z5 z* g6 w' |* M4 D& Gmatches方法试图根据此模式，对整个输入序列进行匹配。
( X# m3 f( g; ]( z7 klookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
" |/ I  R# u1 q; [- k/ h$ xfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

4 K7 r( @2 Y, l( j. ~% ]" r这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
) U% K1 P+ K% D4 S8 \7 Y# e
0 }# ^2 w! t) J/ f+ y6 `  H这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

; T4 {' q. [+ M2 a. J# T5 N* uappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
: `) I$ P9 l- J. f9 ^
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

+ j. _+ S2 i0 }' F# V+ p" u; ]CharSequence接口
" b- E5 s; d! z  J  q7 W' c/ I* ~
# p" c; W" |) DCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
3 L" `" ]$ z, _* x# o0 \. K5 O4 q
/ ?- D6 [/ I3 Y% E4 ZRegex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
" U# u* K0 _) V7 J" Y+ p$ j7 k
4 ?2 N4 I6 S. S( \+ d7 }简单的单词替换
) x3 Y( k3 i: x, |7 y" ]1 L
5 {. [) c* H1 W& L9 A  Q/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;
% z3 n4 ?. [& d, V
& J% Q8 ^% Q9 \# e, Opublic class Replacement {
public static void main(String[] args)
6 Q7 U) V4 \( j1 E* }; E$ ^       throws Exception {
// Create a pattern to match cat
! U( a. f" _: a: nPattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
3 x: a! P: P/ u0 LStringBuffer sb = new StringBuffer();
8 v: B: b1 H( A  l0 Nboolean result = m.find();
// Loop through and create a new String
// with the replacements
5 a$ M5 J/ B5 bwhile(result) {
+ q3 R- |& v# I5 R0 Lm.appendReplacement(sb, "dog");
result = m.find();
! ^" ^' t! h% D  [}
7 g* ]! n. u5 k5 n// Add the last segment of input to
$ W" k% ^3 `, X2 a; W// the new String
m.appendTail(sb);
$ \( V; H/ l# |1 m% v9 FSystem.out.println(sb.toString());
}
9 G/ o5 i5 y9 R, T% r! n# l7 K}

电子邮件确认

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

3 G  K$ o8 @" e# }3 [/*
* Checks for invalid characters
2 A5 b- J, H; [" j; e* in email addresses
6 z* r& r/ B6 G7 U/ X/ j5 T*/
public class EmailValidation {
# s* w0 {5 X+ F7 L+ wpublic static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
//Checks for email addresses starting with
% E4 K8 q  j- C6 k//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
5 `' I! _; y# b! \% fif (m.find())
System.err.println("Email addresses don't start" +
2 C, T; m& ]9 A9 ~6 F. ^         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
8 |( X& ?! @# K: j, l/ qm = p.matcher(input);
if (m.find()) {
* @, V* J+ q  F4 o2 K9 `System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
# [( P4 E% ?9 K+ [, }" hm = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
/ }! h7 G8 E+ x8 e, Z, K- a! c
# x, ]" Q: a% w7 T* R1 Swhile(result) {
3 K9 t$ x3 E) R; PdeletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}
7 S3 `: J) w- J+ M/ m, c# f
8 ?& G# h2 m( c, A# a' Y& D5 H; R// Add the last segment of input to the new String
m.appendTail(sb);
. `8 G1 Z7 |/ p
input = sb.toString();

6 k3 q; [9 [# a: r( S' \# R. p8 Nif (deletedIllegalChars) {
: V7 s6 T( N+ L& ]  D1 v# I! vSystem.out.println("It contained incorrect characters" +
" P" S  T$ {( g" {0 H       " , such as spaces or commas.");
0 ]+ D/ m/ n$ x, o+ S# u; K2 e}
}
}

: l4 L0 w$ e3 G0 l7 E% n% v从文件中删除控制字符

% i. I( D5 L& `9 I$ S- }8 i3 d/* This class removes control characters from a named
9 ]' z: R& j3 u+ Y* file.
*/
import java.util.regex.*;
$ s7 I& C' `( [import java.io.*;
- g" }& [* n7 J/ y, t" l
+ c2 m1 m( _4 b' cpublic class Control {
public static void main(String[] args)
           throws Exception {
           
5 r" F- ~/ ?" ?6 r2 [+ m- Y; `//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
/ ?- g0 L1 H. Z7 V4 D* WFile fout = new File("fileName2");
' s! \+ ?9 H1 M1 _//Open and input and output stream
FileInputStream fis =
( }  b, [+ K! C8 R8 `       new FileInputStream(fin);
FileOutputStream fos =
2 J6 K# u2 L8 P, Y0 b' _: Q       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
9 K4 D% t9 z6 \+ B8 O- N. d  GBufferedWriter out = new BufferedWriter(
7 X. y: f1 I' }& m# U     new OutputStreamWriter(fos));
: ~* |  p- i' a8 |1 x# s
5 `, B- g7 q0 e2 o// The pattern matches control characters
! S2 @  w, ^5 \- s; S* c) IPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
) h1 ~3 o/ l* e& z% WString aLine = null;
while((aLine = in.readLine()) != null) {
7 F: d# Q3 T( r! pm.reset(aLine);
//Replaces control characters with an empty
7 e, t( A) D8 f* R$ L, B9 c//string.
String result = m.replaceAll("");
+ }9 R8 h+ g  z* M6 e/ T8 {out.write(result);
out.newLine();
; r5 Y! O+ b( g}
in.close();
# T5 a# |) q3 U. z! Wout.close();
}
}

文件查找
, I$ x* h$ \/ G! A' Q+ Y
  O7 }/ n8 e4 S1 g/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
4 @; G  T' P( Y. Oimport java.io.*;
import java.nio.*;
import java.nio.charset.*;
0 S6 Y3 D, G! h0 |( Z- ~import java.nio.channels.*;
- u/ n) k5 a) d# F* [
0 d, ?) F1 e# O' C8 apublic class CharBufferExample {
6 v8 P# Q4 G5 A. Tpublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
4 ?$ A: e9 Y( n( i0 q1 kPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
9 G0 J- n* N: \) }File f = new File("Replacement.java");
! E& B+ o& m) ?FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

2 I! D5 p3 w' G" k( J) [# x// Get a CharBuffer from the source file
/ l" ?& {$ A* b& y( ~; `* b# YByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
1 S7 h7 D$ o0 ~2 U- W  JCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
. Y8 o! ?# @  v' S" FMatcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
4 [" E! l) u) w, M$ ]}
8 V) r( p- y* y8 o$ j}
$ q& e! W$ A& A7 e4 s, k
: H. h( R# O6 a+ R/ f8 U结论
" c6 l8 c" y' Y8 |现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
. q8 C7 d8 L& E/ u3 H6 `9 x
JDK1.4之正規表示式
written by william chen(06/19/2002)

1 j# ?: B: p4 T+ o5 y( D& j--------------------------------------------------------------------------------

1 O6 }) ?( }9 n$ h什麼是正規表示式呢(Reqular Expressions)
) G- [+ {# l% ?
0 |9 s. b2 g1 ^# @7 A  R就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

9 S# W& a7 g3 p3 J7 E1 R所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
8 |( n- w+ ~/ d) |3 ?6 ^
; e, f$ E/ M# `- Z剛剛列出的一串符號" s/
9 y: Q& h  t# Q適用於j2sdk1.4的正規語法

"." 代表任何字元

7 h0 p% z' j0 v, r5 _' _+ v正規式 原字串 符合之字串
0 D  u  {& m9 i* G. ab a
" w" C& X, f, y; ~/ r5 K.. abc ab
" D  l* m+ [# G2 l& [
"+" 代表一個或以個以上的字元
* c1 H4 y2 U* Q7 o- }3 x5 K"*" 代表零個或是零個以上的字元
3 b* M; ]8 Y. G4 i9 i2 ]; w8 k
; v9 r) L) v9 B! R" w正規式 原字串 符合之字串
& E# I4 t$ Z4 \+ ab ab
* abc abc

"( )"群組

正規式 原字串 符合之字串
+ u# X+ T+ x$ \8 R(ab)* aabab abab

字元類
# x+ N. H  ^8 I  @& c
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
. P: g" e$ p, |. j[a-d]* abcdefgh abab


* `$ q8 Z% X$ U0 J. d. e+ j簡式
8 P& h: z3 X: R8 U/ d% G
0 B% Y. }0 [; S5 A6 I\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
8 o/ n2 m$ ?9 \7 ?\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
. P1 H2 S: P6 c; [; r% m2 c
每一行的開頭或結尾
8 }6 r: W# ]0 B: D8 |7 `7 i$ @
^ 表示每行的開頭
8 v# f5 E* I& [$ 表示每行的結尾

--------------------------------------------------------------------------------
; A! A  W* Z9 r" z
正規表示式 java.util.regex 相關的類別
# F- R" O8 i- i) R9 E2 P/ x
Pattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

! L# H+ \9 s/ d5 h- r% b0 l範例1: 將字串中所有符合"<"的字元取代成"lt;"
# P( U$ H' C2 G  s+ ?+ d
4 H; ~9 S+ E# X+ A( c! A# eimport java.io.*;
import java.util.regex.*;
' p& j% o4 C, T+ A8 b/**
5 I$ a# Z, K: q' e/ D3 [( Z* 將字串中所有符合"<"的字元取代成"lt;"
6 M6 w+ T- r0 l* m*/
public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
' g4 \( s9 c! O, FPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
5 g9 g& A5 F1 K% [2 M/ dtry{
9 Z5 K7 {) W* E$ v, G) ewhile (true) {
7 y3 p; |+ z! x9 g3 c9 d% Z$ B. H9 jString line = br.readLine();
// Null line means input is exhausted
if (line==null)
9 u- `* z. q+ B1 r$ q. Rbreak;
+ {6 e- f1 I/ X1 N+ t/ aMatcher a = pattern.matcher(line);
while(a.find()){
; T5 N/ H4 _' J& ySystem.out.println("搜尋到的字元是" + a.group());
& r9 P! r8 _. y; y$ F! n8 a}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
) P5 ~3 _  ?$ [/ U( A}
}catch(Exception ex){ex.printStackTrace();};
}
) [3 Z) I1 O$ s
範例2:

import java.io.*;
import java.util.regex.*;
/**
  D- e% @& i$ u7 M+ h* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
// BufferedReader lets us read line-by-line
* D/ s2 f7 E3 D, l" X* RReader r = new InputStreamReader( System.in );
& Q& L- [4 W$ `9 P& |+ j9 h8 _, PBufferedReader br = new BufferedReader( r );
2 O& B7 K. V- a7 WPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
1 v3 z: q6 y9 l0 \4 v// -1 means we haven't found a word yet
# F' U) v8 p3 {, X! B0 j/ j" Bint longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
' m) g  j$ s% J' g; j( F" dif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
5 Q5 q! c. M% o5 @2 m  b& J- {}
}
System.out.println( "長度最長為:" + words[longest] );
7 U: Q5 `) W) R, _& o% \5 F5 c, X}
$ P$ g$ ^$ g7 r6 h}catch(Exception ex){ex.printStackTrace();};
}
; o: x" d6 X* K( u* X: ~  g/ k8 Q1 }
--------------------------------------------------------------------------------
! _4 v3 g9 a5 _# K% d! O8 w& _5 \: H
0 I0 l( y" n% C  {' E$ p) l其他的正規語法

/^\s* # 忽略每行開始的空白字元
+ c& N5 P& a2 C( J( [2 H(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水