关于正则表达式---ZT

Longe

第一部分：
-----------------
1 t; C) l' {1 O% `; ?1 U正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
0 D5 N) f1 ^; D9 v# D+ i1 e
" J* G0 L- c' d支持多种平台
2 G1 L. `) R* K0 V% t
/ S# V8 d; X* A4 v+ j0 c" U
0 ~' w, i: t, S- e' m正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

, D! f. D( Y* \正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
* ]) m7 A% b' G; N! E* X" s
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
5 _; |+ c# r6 K- e' b
' i, l/ g" a% s# L) h5 Y! h比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

* S8 z- x: l9 p- {* r. K; c9 f正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

: |; L( ~3 w2 d6 Z. W/ E第二部分：
' C) [* f9 O- }0 n9 K- L' F----------------------
# G6 k# l$ Z2 x' ]4 J字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
( K" ]# Z( K. H; }* z
每一个表达式都包含需要查找的指令，如表A所示。
% ~" G5 t; c5 r/ [
Table A: Character-matching regular expressions
5 \: @+ @' h/ D( p4 {0 |& b8 m0 [" m格式说明：
$ c5 Q1 \0 \/ V7 w1 I---------------
操作：
9 w3 e# q$ O. ^$ q) p! v0 m2 y解释：
例子：
0 v+ z% T- I2 _. W9 a( @结果：
6 W0 T5 L$ g; A  B* R/ ?----------------
.
Match any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
3 _" m5 w. S! ^3 r4 x-----------------
# V; B4 r! @6 W: Y[ ]
  Y, _8 J: v$ t" I% W/ r0 {Match any one character listed between the brackets
+ f: [9 p, s# |- p1 [grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
+ u  I4 B, x) Z6 {8 l---------------------
# A( K1 m( a/ u[^ ]
Match any one character not listed between the brackets

) V5 v- m! f$ ^6 v# m. p* t% Ugrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

' K: @- d/ P+ g2 u* igrep [a-zA-Z]ord sample.txt
; n9 W9 k! \- \Will match “aord”, “bord”, “Aord”, “Bord”, etc.
9 l8 T' I, l1 x
grep [^0-9]ord sample.txt
& P5 Y/ k% ?4 ^# A, W2 m  y9 [, ~3 tWill match “Aord”, “aord”, etc. but not “2ord”, etc.
: y9 J: Z$ H) P4 `+ [
4 e( a; `+ m8 B7 E1 z* Y) r2 }重复操作符
& p+ ]7 n: u( J2 W. |, l+ ~9 ~重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
- z8 T0 }- i/ _9 k格式说明：
---------------
操作：
4 d$ n2 d. }9 X% ~# |/ K; r6 h解释：
例子：
" }0 m6 W) x% u9 m/ ~' M: L结果：
----------------
+ o: O* F/ M% D$ u+ U, \?
6 m6 f6 |0 l9 C( ^- j# j  s7 gMatch any character one time, if it exists
3 f9 l+ h+ @5 {% f7 negrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
1 K2 x: f; m7 s/ @  J$ C) L# }, M- c) _; @------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
& J3 a5 D4 D; D: {# j+ JWill match “nerd”, “nrd”, “neard”, etc.
$ C4 o. |1 }9 j-------------------
+
( Z4 t# M- Y3 P" X' q9 \" WMatch declared element one or more times
+ \8 A3 A8 ^. Z- I, [  Tegrep “[n]+erd” sample.txt
+ S" d- C- |( K' n- J( OWill match “nerd”, “nnerd”, etc., but not “erd”
0 t# Z! T* ~: v0 V- D--------------------
6 t7 `. T/ j$ E6 W9 |1 o{n}
Match declared element exactly n times
3 d& s3 {7 y; v9 Zegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
7 `8 W6 d* I6 ^" v* O------------------------
{n,}
2 ^0 b- J( u# R" T0 g6 U4 QMatch declared element at least n times
egrep “.{2,}erd” sample.txt
, i  O. m. D* y. [9 _' qWill match “cherd” and “buzzerd”, but not “nerd”
- r) Y2 }& [! l; z0 r# D  f------------------------
& _( f$ g/ B0 q; a" S7 Y{n,N}
& P4 r2 N2 n. s$ ]" l+ O# aMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

  }9 @( U& O0 j* x  O$ s9 A第三部分：
: z8 A" ~  w. b7 B! J----------------
锚
9 l% O9 K+ ?/ w/ ]! R锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
# }6 Q5 y# X7 Y/ e. W* ]% @
7 P  N+ |" p  V# Rs/pattern_to_match/pattern_to_substitute/
9 B. ], O! u( W* Z
; {) Y' j- d5 q5 q0 [' |2 u, s1 {
Table C: Regular expression anchors
+ T6 d) g- C+ J/ ]) `# l% ~! W-------------
. E: J* Z4 @, n' Q0 [操作
3 r& ?, h6 Y2 W; O6 P  J- [解释
例子
结果
---------------
% f/ w- C# u' ^* [: |, V^
  c$ f4 w! G- |0 y, SMatch at the beginning of a line
' j% p0 I/ L% js/^/blah /
9 v( o' w- G! y6 ]  n2 \5 L/ _Inserts “blah “ at the beginning of the line
---------------
$
; ]: `4 D# d/ V7 gMatch at the end of a line
s/$/ blah/
) q7 f3 X! k% qInserts “ blah” at the end of the line
* }3 S% p4 M. U+ p  u% y' R& H---------------
\<
: d+ A1 I/ M9 KMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word
5 `) O7 Y( `4 }! r
: y1 a. K, b1 K4 y. P% K5 \egrep “\Matches “blahfield”, etc.
7 N  Y  f6 c* G: H* u7 _------------------
\>
4 ~  I6 t& K7 w# Q8 ^Match at the end of a word
6 y9 K7 @& C0 O6 s/ q7 y9 {s/\>/blah/
Inserts “blah” at the end of the word

egrep “\>blah” sample.txt
; f0 `5 ^( Q2 s: b0 G$ O3 ?Matches “soupblah”, etc.
---------------
' |; J8 W8 Z" n% y  r\b
/ \! X9 H. ]' |5 `& O- ?% I% D: mMatch at the beginning or end of a word
& Y, J/ v+ d* Q9 ], jegrep “\bblah” sample.txt
; M3 W! P# p7 Z8 F$ jMatches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
3 e6 y% l9 k& l4 V7 A6 ~0 Y0 m/ eegrep “\Bblah” sample.txt
' m% W7 q  q- s2 UMatches “sublahper”, etc.

间隔
& j: b' F7 `6 ~, [, l) K. @& f
+ e+ y- O3 Y- |Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
2 T& z: A# ?9 Q( w
egrep “(n|m)erd” sample.txt
. Z! A+ E  }8 S
0 q$ `" h( p! s间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
9 Y8 w! a4 M* L' a" Y
2 P2 s# F3 g  D1 Y+ @% e) g# \1 segrep “[nm]erd” sample.txt

( c& W$ c5 u0 s当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
  q2 Z) ~0 A5 [% M1 w' H' i
6 @, }- v+ ^- P# G第四部分：
1 G% k& p; R+ b. f& G2 j' j----------------
# I* w6 }( A  C$ n一些保留字符
1 y+ E1 w7 }) y6 c6 S' wRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
( Z, c- x1 f, |6 N" X% p2 b
+ D# e# z) X  K. I$ W$ U^ (carat)
. (period)
+ z- G6 t$ p) O. @' [2 _[ (left bracket}
$ (dollar sign)
( (left parenthesis)
" e# W" A) L6 i4 b7 W; [" ^( g) (right parenthesis)
| (pipe)
* (asterisk)
/ ]2 S: p  v+ U+ V% u8 l' G+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
\ backslash
! B8 D" n) C% ~' H# m  Z一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
; p1 ^1 C/ ?! T) D" `" z1 A" U
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

" T- A1 Z3 U6 s& G5 o5 g( R, u你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
4 D: N9 [# T$ K: I* z& M
! v; u, X2 B2 G/ w& G8 o: s# x总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
  s. n8 M3 _4 s  ]; Z" H----------------------------------------
正则表达式和Java编程语言
0 g6 x3 l! g4 c8 D. X-----------------------------------------
; O8 s& G$ X/ T/ o类和方法

9 H; F9 G* N  \) m/ o4 s下面的类根据正则表达式指定的模式，与字符序列进行匹配。
& s! M% e, r3 L6 x% `
Pattern类
. K! j0 S& {% g8 J" {* x
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

! e+ X( K4 ~  l  [% [( H用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
4 l4 M) ]' j; K% h, n
. [: ]) H1 y8 u用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
% Q/ }7 t2 |( [# `) ?1 j* {! m
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
  h4 i1 r7 w1 `# t6 i; j4 x*/
2 h: n4 \$ d7 |) yimport java.util.regex.*;
# \3 N& I1 k: S9 a1 \
" x: s9 ?8 J) c8 ]4 j+ fpublic class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
9 v! ~% ~' E' I# |3 ?  i9 ?5 C( x  fPattern p = Pattern.compile("[,\\s]+");
& Z% X5 a0 r! r) J. h// Split input with the pattern
& S6 A) p% p: I5 y: E4 Z" e' C9 E' pString[] result =
   p.split("one,two, three four , five");
4 T! E1 S! n0 X6 i3 zfor (int i=0; iSystem.out.println(result);
}
}

8 p! F" L/ T- J9 i3 Q, j$ vMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
, W% x- |# G" P: Y
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
7 z) w) Z  N; \5 \
matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
- ^3 b* O" E+ ?7 s4 }* U& T
" C% c: a6 W3 H% r4 s5 `7 @; G4 c8 n这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
" R, ~- J0 h( e( C
5 ]. _3 B2 m. y% N) U6 m这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

" U" M0 G0 M% y2 LappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
, _7 t8 B, D+ v! [
CharSequence接口
: g' e1 U5 x/ \' g* D' _! u
% n9 T7 f" H* }- s2 c0 E8 a* _) KCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

% h! E( V' ?) O' q2 L/ z, v2 |Regex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
% v3 |' }& r6 x
简单的单词替换

/*
, A) G) K9 j' M; @7 k) i( d* This code writes "One dog, two dogs in the yard."
, W' e. w0 T& u& Z* to the standard-output stream:
*/
import java.util.regex.*;

public class Replacement {
0 r+ V7 V$ F. K: e7 ]public static void main(String[] args)
; }! C, i/ w9 ?+ [# G6 \! t$ [       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
4 Z. A! {2 m% ^Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
% U, m1 L& K  B: R# L9 {+ l// Loop through and create a new String
7 ^* ~9 c8 d8 l3 g( v// with the replacements
" ^7 v, ~, Z4 L6 `while(result) {
( X; \8 E$ ~4 vm.appendReplacement(sb, "dog");
result = m.find();
- V; j; |2 v+ g, \; e% v8 K}
1 P( `+ ?$ ~$ Y7 {  B" t// Add the last segment of input to
8 M4 Z2 Y' H, X) h2 Y( Y: M) I+ Q// the new String
5 f* @1 _- k/ R- p: qm.appendTail(sb);
! g; |. O! v! Z6 NSystem.out.println(sb.toString());
}
" h0 r' Q; o9 ?, {) T4 l" l}
) B6 w' m8 h! b; ^% A4 R
电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
1 a6 H) y& _6 w8 s$ u6 i, a
1 l% r& M1 k$ o% p9 A2 J/*
* Checks for invalid characters
' O! @" m1 D, [% y* in email addresses
3 _! f; {. v9 G7 t1 C; I$ {: \6 C*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
2 r' @) r1 N; ]% |! w  B2 S$ k* P* h           
String input = "@sun.com";
$ o0 q0 I8 }- X5 m6 [//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
2 p2 y* ^4 n7 u. f9 bMatcher m = p.matcher(input);
7 q: ^9 ]! K+ {* \! c9 Uif (m.find())
System.err.println("Email addresses don't start" +
: p! P' Q" l3 b         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
  q* H2 V$ W9 C: Z9 \$ T3 p1 ]p = Pattern.compile("^www\\.");
1 P" v- I( o. ^9 A# [5 n+ ?m = p.matcher(input);
5 L  N& }" j; r! K% dif (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
7 ?7 B( ~7 f0 _, k# w" am = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
  m9 k8 Z# u* i. }boolean deletedIllegalChars = false;
) p" x, P: A! M3 F; a
7 H0 _) n8 _& [; {* t" @2 w4 ~while(result) {
6 ?9 v# Z* S  E( B5 d0 J8 r8 J' jdeletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
, X. u3 r& t1 b}
; @, r/ V3 [( ]
/ n* e! }) C9 x( R5 B& d5 |* d  B( ]7 V// Add the last segment of input to the new String
m.appendTail(sb);
+ Y- p  U& {2 N9 w7 k
input = sb.toString();

if (deletedIllegalChars) {
) b" A. b3 i. dSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
/ H! P9 _/ i4 R% y1 d  y8 c}
}
}

2 u. f: Y" k  y4 P从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
* c) D7 P1 z# `) t+ rimport java.io.*;

* i+ @! V7 R$ [, u: D$ `, N; zpublic class Control {
" f# f& @" a% c  \1 @public static void main(String[] args)
/ z( `% o" K3 M, o# d           throws Exception {
/ H$ [8 T' Z8 O# \           
% R: b4 k: u. {//Create a file object with the file name
//in the argument:
. D2 C* N$ Z7 C3 @; c, H+ w% cFile fin = new File("fileName1");
File fout = new File("fileName2");
9 U% m! ^) C9 x0 P//Open and input and output stream
5 j; I  A6 c8 e/ S1 v8 J3 dFileInputStream fis =
       new FileInputStream(fin);
7 r9 e7 Q: Z: X! @& c: UFileOutputStream fos =
       new FileOutputStream(fout);
. m$ L" z% }$ U0 q0 _" `5 n6 V
BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
& C1 K/ {, q, G+ q1 C     new OutputStreamWriter(fos));

// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
) s9 {( E) J; w9 N. pMatcher m = p.matcher("");
String aLine = null;
; S3 b  E# `8 J3 P. J. M  W4 B5 iwhile((aLine = in.readLine()) != null) {
. o$ R8 U' A9 L. _m.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
2 j3 H" p9 G$ ~1 c}
: _! M3 T+ ~& N( [' p$ R* zin.close();
' }; N; [8 a/ b8 z. Y8 ?; \out.close();
9 `# e1 u# W7 N}
}

文件查找

/*
+ m' q- z; a- {, g* Prints out the comments found in a .java file.
*/
+ L' r5 y, f+ ^7 Aimport java.util.regex.*;
import java.io.*;
import java.nio.*;
, ]4 ^& q: Z3 a  {( i" wimport java.nio.charset.*;
& `% @/ D$ s) u4 {( w/ R" gimport java.nio.channels.*;

* L1 b0 q0 R. S# [0 X9 gpublic class CharBufferExample {
public static void main(String[] args) throws Exception {
* d- s9 b+ N! o$ }. x& X, p// Create a pattern to match comments
. M0 S! x+ |& p7 DPattern p =
2 \6 Z' {, }/ BPattern.compile("//.*$", Pattern.MULTILINE);
/ P0 M) v4 N2 q0 L: f9 T3 V
9 H# q% A# }; c' r, B! e// Get a Channel for the source file
6 o2 R% D: x: o. c& eFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
, t% }% [4 z& g6 gFileChannel fc = fis.getChannel();
7 H! Y- H- Q1 j4 q8 X2 [+ Z
1 {1 O$ J4 G" l9 `+ A) O// Get a CharBuffer from the source file
ByteBuffer bb =
* y1 Y' u7 B- q. A5 X: zfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
/ m# W! f6 p+ h" R* [Charset cs = Charset.forName("8859_1");
8 @: e7 i! O0 c' n2 bCharsetDecoder cd = cs.newDecoder();
) M, p% n+ d1 z9 A4 v( X6 yCharBuffer cb = cd.decode(bb);
( v. ^+ t" x* V* o
$ X6 F; M! x  o2 t* t4 N2 G3 N0 n// Run some matches
Matcher m = p.matcher(cb);
4 a: v* [7 j( i% I+ Y7 Kwhile (m.find())
! w; }! \  X9 ySystem.out.println("Found comment: "+m.group());
}
}
- s& W( g/ O: O: b# w) `3 k* A
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
written by william chen(06/19/2002)

--------------------------------------------------------------------------------

/ }7 [2 R) z9 Q4 {/ P! i什麼是正規表示式呢(Reqular Expressions)

6 H; {$ r1 ~8 O. }' |3 z! X! _就是針對檔案、字串，透過一種很特別的表示式來作search與replace

( p/ L( R: Q5 a* U# O; H因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
' f/ K1 g* ]: G, A
' a$ U3 e5 g1 B' C所以發展出一種特殊的命令叫做正規表示式

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

5 x+ g$ p5 ~% a+ ]8 ?8 \" N/ h若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

* ]9 k" |" J& x. x! o7 M剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

: h; B- V0 i0 n$ @"." 代表任何字元
8 ], Y! D. [+ w+ A: I, D  [' p. g
正規式 原字串 符合之字串
7 c. N7 V( Z2 P+ z. ab a
4 g0 i) ^. I8 U4 E; f7 g.. abc ab
9 }6 _, G: U# S2 M+ L% V
"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
1 H9 h9 |. q- |1 n5 G+ ab ab
* abc abc
+ r/ O% i% c' b% Z
% v% y7 z- M% t0 u"( )"群組

正規式 原字串 符合之字串
9 ~  \5 \: k0 m5 Y2 L. k$ C$ R7 y(ab)* aabab abab

6 \, w. T: s) P4 ^; {4 K4 c9 @7 B字元類
: x6 B0 y3 n# e
' @/ ]! c2 b! P" U' u$ }( s正規式 原字串 符合之字串
, O2 _5 f5 D3 U, g6 B2 Z[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
, R. p- j/ W" d! X& }% ^[a-d]* abcdefgh abab
3 b. ~+ G" w2 K) B3 L

- }8 b+ [$ i7 M  Q0 q簡式

  _: ~( `! ?; q\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
, P; H6 S" H. n& o\s 等於 [ \t\n\x0B\f\r] 空白字元
% Q4 N: F4 z; K7 G& y' s( t9 y\S 等於 [^ \t\n\x0B\f\r] 非空白字元
. V+ I9 l7 w' R\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

: `2 _& o: Q  v, E% i5 @) w每一行的開頭或結尾
: S. S; M/ Q2 u' A6 i- @5 Z
^ 表示每行的開頭
$ 表示每行的結尾

/ U0 {9 G) [! Q% W% b2 q--------------------------------------------------------------------------------

6 E7 _% r. h* Q! Q' s3 A正規表示式 java.util.regex 相關的類別
$ D6 e3 x3 S" n4 M. }+ I7 ?8 @: J
Pattern—正規表示式的類別
  C$ {$ K# Q8 q- j$ c7 _Matcher—經過正規化的結果
1 c0 {4 U( m! d+ h7 j& mPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
2 ?- L4 C4 W- q0 J; W! \0 v
範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
, Y; D$ J$ n  ^( R4 ]. t$ Himport java.util.regex.*;
, ^& s) M( g5 y7 E/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
// BufferedReader lets us read line-by-line
0 Q* K$ n- d  eReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
) u1 s1 j  [, B' @  ^, U+ {while (true) {
# t. ^' w) H: {( YString line = br.readLine();
2 ]- Y; c2 c% K, O. a// Null line means input is exhausted
% |) e6 O# C0 |# H+ aif (line==null)
* j; I4 r1 Y) qbreak;
* S& v3 z. a0 ^Matcher a = pattern.matcher(line);
' R( {9 }/ V! j/ ~while(a.find()){
' w! `# V) b+ s+ C2 Q4 JSystem.out.println("搜尋到的字元是" + a.group());
}
. D. e% f. M* m* G6 rSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
5 b' f' l$ w( `' d7 Y9 o! u, }) F3 L}
# m: ^; {) \" |- U}catch(Exception ex){ex.printStackTrace();};
}

範例2:
. I/ d  x& \# `% q" D
" m( i( _: a9 A% Oimport java.io.*;
5 a0 ^  C1 [; p8 I8 g9 w0 ^import java.util.regex.*;
/**
4 q  J, h3 u' K8 [8 Q. l* 類似StringTokenizer的功能
9 q5 O4 s' n# k, w3 O+ {) y* 將字串以","分隔然後比對哪個token最長
*/
# _( Q, M2 d# E# n5 W1 |public static void search01(){
* b6 J6 p( h4 i! w' y7 _// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
  \* u% E: b. L) f6 hPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
5 C* e1 B, b( r- r; mtry{
while (true) {
String line = br.readLine();
4 t5 }- U3 Q! R8 W, `String words[] = pattern.split(line);
$ O* J$ P, M) }( v) t( l// Null line means input is exhausted
if (line==null)
0 B6 `, Y: b, Q2 @2 ubreak;
! l: R, j) h2 C" |+ X% M7 ~, x' F// -1 means we haven't found a word yet
int longest=-1;
) L  Q, y/ v# n# F6 j- ?int longestLength=0;
% y8 Z& Q: l; F  Efor (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
5 P: N+ |/ ]& ?) H( H& ylongest = i;
longestLength = words.length();
8 K6 t7 Z" b# {. q, q  ]. h+ v0 {}
# j+ P* u6 V# P0 F0 B}
System.out.println( "長度最長為:" + words[longest] );
4 y" {0 B7 b. R3 w}
}catch(Exception ex){ex.printStackTrace();};
}
; e( u  S4 J& H. q4 U
--------------------------------------------------------------------------------

6 `5 R9 \$ Z  O' o( D( }% L其他的正規語法
: c; E+ u  U, @. p, \6 l
' n/ r$ u, N/ M. ^3 m/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水