关于正则表达式---ZT

Longe

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

% }8 V, O8 {3 R支持多种平台

/ u/ {9 o3 {1 _7 H1 {/ f
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
2 E: g, c  \; |! o; u% l0 W4 @
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

) r4 R9 J+ g& G6 D$ I7 z许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
0 y: N4 k$ ~, C1 B+ N7 k- Y
6 Z8 J  M" K6 |" z& q3 J8 J比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
% N) V) q" E6 C5 t) B" J# [
8 k: o. o* w0 M* o: A/ `第二部分：
----------------------
字符匹配
7 y) f( y$ U8 N) a9 o' h$ _
8 k; R) n$ t7 B& t- _+ j. r% ?正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
+ P) i2 ^+ R+ x* `
每一个表达式都包含需要查找的指令，如表A所示。

5 A$ a! M; w$ W" h3 D4 @Table A: Character-matching regular expressions
格式说明：
---------------
操作：
. n5 Z4 t$ t1 ?解释：
例子：
" X9 s$ j1 O( G% I5 U- [结果：
----------------
3 \" L1 z2 Z( M# K* z! h.
Match any one character
9 u% F4 H' [9 H3 Agrep .ord sample.txt
) X# F) @1 R& w& s4 h% ^Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
  k) P* ~) n8 P4 w( W; h-----------------
/ B8 T1 b' m, x: k% _[ ]
. E# g% n2 V- M" V' j: k. MMatch any one character listed between the brackets
2 |- L% U+ B# _+ {- N9 c( xgrep [cng]ord sample.txt
- b5 ~( k/ E  y$ DWill match only “cord”, “nord”, and “gord”
---------------------
5 y9 H* @& R- x  Y[^ ]
Match any one character not listed between the brackets

( Y, i6 i! S# d: vgrep [^cn]ord sample.txt
, j/ B7 A) V1 AWill match “lord”, “2ord”, etc. but not “cord” or “nord”
) B$ p% K- `* ?3 Q- i. {+ a# h
; [7 X$ |. b' @* G6 `% N) sgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
# l/ v. H; [, f3 Y
grep [^0-9]ord sample.txt
- \" ~7 {' x+ D/ N+ kWill match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
% S2 m4 h) p5 g, ?* X重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
0 K1 R$ d7 T5 f* Q4 k* h  v
# E+ ]; z# A# s7 ]: K9 J! C$ s" f( JTable B: Regular expression repetition operators
; J. O0 e8 G  i: v格式说明：
( J5 z, g4 x8 x# m---------------
操作：
解释：
- B. |1 ^* j# \: a例子：
结果：
# R4 L0 E6 n7 e8 V----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
, N( L5 ~6 K/ f* B------------------
+ |% E" x* w9 N: X* i*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
3 D& D1 E  w" U4 e( j# dWill match “nerd”, “nrd”, “neard”, etc.
-------------------
. A. H( F, Z3 @+
# c9 G4 A4 u) |) ]Match declared element one or more times
" w. r" O$ v4 T0 oegrep “[n]+erd” sample.txt
$ T  F/ s( ~2 k; f$ _. i1 eWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
9 ^7 s3 J" N% [( r; k9 W3 VMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
$ f  [' R  @! \Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
% q$ G7 D  f1 K1 D' k------------------------
{n,N}
5 R, a0 _, |+ Q4 r- }Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
# ]$ |6 F! h2 }# i3 o1 |( FWill match “nerd” and “neerd”

) A6 j+ Q' O. ?* c7 C第三部分：
# M; L" @6 L3 x9 B$ ^5 A9 I& S----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/


, l' o; l: L2 Y) v2 O9 sTable C: Regular expression anchors
-------------
操作
解释
例子
# ?5 d! [  A" r% u" O5 f结果
---------------
( w$ H6 W7 d  Y. Y3 Y- _3 p^
/ K8 Z# s2 L: v5 ]* {7 {Match at the beginning of a line
8 l3 R& r" z+ T2 ps/^/blah /
: O  |1 R$ S. E0 ?, M, n- r( xInserts “blah “ at the beginning of the line
6 A3 a. L9 a7 Q$ d+ Z+ _---------------
5 `: @4 j, C% l' ^$ K$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
5 l! G0 w  `6 M' W---------------
  X, N+ Q" N" Z, Y; F& O! u' s7 R\<
7 v$ c( N% s# I6 s/ Q2 zMatch at the beginning of a word
+ b# G: l( a7 n  as/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
( Q* B; _, f0 }/ y! ^% c9 K  T------------------
\>
, g8 y4 I$ G% _8 M/ yMatch at the end of a word
, j& @& G( g2 I5 W- Z! J  [s/\>/blah/
Inserts “blah” at the end of the word
4 Y8 K( f: `2 {6 _* f, j
: s0 U1 j2 ^) J' z4 D, uegrep “\>blah” sample.txt
' D2 X9 k# r+ O1 x* c- yMatches “soupblah”, etc.
4 G; i0 i4 A) L5 G8 Y3 s! |$ B$ p---------------
\b
% b0 B0 V3 d* r: R6 S3 V7 sMatch at the beginning or end of a word
' \% Z* w5 F: `5 ~& }; P0 gegrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
+ c+ z, V+ O  n9 T0 p0 ~\B
Match in the middle of a word
* H3 o' @0 f2 E' o, t; x5 l* qegrep “\Bblah” sample.txt
" z" G2 K8 C% k, hMatches “sublahper”, etc.
9 T- {0 j- S& \1 v2 x7 d
间隔
* c7 C# b' A+ X5 C
Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

2 U& g1 ]! x9 uegrep “(n|m)erd” sample.txt

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

0 v9 Q: C  M& Y* X4 ^egrep “[nm]erd” sample.txt
1 c8 P6 A+ E, H- ^3 ]; |. w# i" }9 j
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

# D! @& B, O5 D' X8 v, c1 I  y2 z; V第四部分：
# }* j1 \" P6 L' {----------------
# N; d& |( U0 L* g1 m! J% p; w8 H( r一些保留字符
! _- B4 O/ _" |* q1 iRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
1 N: q9 d! k9 [
# [3 }' n2 w6 N& D, W^ (carat)
7 e2 Z) ]8 U+ b% {- i4 |. (period)
* N& x: j) y+ M, Z; y[ (left bracket}
1 k8 |% f4 d: I* F- c$ `$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
3 e# ^% h+ M9 \" ?, u  M| (pipe)
* (asterisk)
# z2 ]( N- @# ^1 A8 d+ Z  x8 g+ (plus symbol)
; n1 X3 H' L# o/ F" D? (question mark)
, q" r2 S( j, \% n6 F{ (left curly bracket, or left brace)
\ backslash
- f9 ~: u6 B  z* X一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

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

: Z6 f/ C1 x- d" q2 n! @7 i你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
1 S7 x, s7 Y+ N7 X5 i
* f1 E1 B: ]$ L+ O总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

6 {1 `% z- ~1 h3 B9 |8 l2 n另外一篇文章
6 P) V3 _5 J" ^; |6 T----------------------------------------
正则表达式和Java编程语言
3 l. p; z) b8 L. |0 ]-----------------------------------------
类和方法

下面的类根据正则表达式指定的模式，与字符序列进行匹配。
' b1 J* }/ r' l: L/ x! I
Pattern类
& I, N- G9 \* n# y: E8 Y
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
( l3 c  W& X5 w0 d' P
4 r, G: @& M$ V2 x用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
$ W3 J/ i# [6 Q$ g2 y
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

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

/ `( ~; r' K. n" Q) x* y1 y/*
1 b2 E- `, K" B6 J% [* 用split对以逗号和/或空格分隔的输入字符串进行切分。
/ c8 [7 e4 }# N! c* R( ?- P*/
) |6 _3 ~4 I- @8 H6 s) O6 J3 i% jimport java.util.regex.*;

public class Splitter {
7 i$ D* z6 ]  U6 a4 F  Qpublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
String[] result =
0 p: ]! Q/ H2 o' a, ]2 ^   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
}
6 L( f" B; M9 g9 d; l9 N# i
Matcher类
8 }% s. j; Y! D# w# \
  h0 m9 T9 i8 C* AMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

" n6 C2 p& T& R  J/ B通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
9 T" y' g6 d7 H# W# O. u
  |6 a8 I$ i% V5 s( Y% _( o% amatches方法试图根据此模式，对整个输入序列进行匹配。
( R" n& S$ l6 t4 X6 V7 Q8 N; KlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
2 k" q& W8 `5 e, o  W0 e8 qfind方法将扫描输入序列，寻找下一个与模式匹配的地方。
; y4 Z4 C; s  i8 o( {6 L
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
' |6 U' [" v. ^& Q
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
* H" R8 G& w, E7 o/ A
) O2 V! X, C6 K例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口

, ^$ b8 y( O0 D* x6 vCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

7 W) c4 V. g9 N" L# O4 ]Regex情景范例
0 j+ H# r3 ^+ Z# O. v; i9 x3 D8 [
4 {1 f+ J4 v- O) |7 g以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

( W$ A1 B- X  F/ y; \2 C+ W简单的单词替换

/*
- F9 w: Y+ s8 |  i5 L) |* This code writes "One dog, two dogs in the yard."
, A" g$ t: j- U5 K/ _3 l* to the standard-output stream:
( y7 E- ]) ^3 r* L' {- [% b3 \*/
- a4 S) Z; {2 L, h" q# ^import java.util.regex.*;
4 [$ U& A# a- {: Z. h0 d+ x7 j
public class Replacement {
. _$ X. e% w, }# z# G& @$ @% E" fpublic static void main(String[] args)
. A" `8 H: F8 s6 \. F       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
' q7 e) N8 U0 V- J. o// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
7 ^) {; m6 v& a8 b     " two cats in the yard");
StringBuffer sb = new StringBuffer();
, |4 U; u0 W( V9 W7 A5 h# w1 _6 }boolean result = m.find();
  Q7 L7 u. G  A/ K! j+ L" {// Loop through and create a new String
// with the replacements
! U1 e, N% \  h2 a4 U+ C7 Ewhile(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
' U5 M9 X2 R1 {, w& P% |7 P// Add the last segment of input to
1 U" y3 ]1 c- e6 T' H) {- d8 E// the new String
& K/ f) q6 R) U! zm.appendTail(sb);
System.out.println(sb.toString());
1 ]7 [  b2 n- H! w* D6 Q  X: `}
}

/ F. M5 d4 {7 c- l8 o% Y( J电子邮件确认

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

/*
* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
& b! o3 O8 z9 ^( X; h( D' r           
String input = "@sun.com";
7 E1 j3 g- o  O7 S7 [# m, b5 A# E4 k! a//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" +
* ^, t. C2 @6 N' H9 T1 P$ B1 ?         " with dots or @ signs.");
7 ~& b1 ]0 \2 u! q; L8 v//Checks for email addresses that start with
8 k% z  L9 w( d//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
9 W5 e! k! r% O# }! q* g9 [% tm = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
4 t: w, p3 V) M* d, E   " with \"www.\", only web pages do.");
+ X* [, l% i  B2 N}
2 v. Q+ Y. ~' P) f/ L5 rp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
: U( ^9 s, X2 m5 q) S1 g. U$ aboolean deletedIllegalChars = false;
" K5 L" A, D) v8 M% w6 \
% W# ^  T5 S# E9 o+ [while(result) {
! |2 k) e: W3 p2 g8 s1 @deletedIllegalChars = true;
4 R9 Z6 p/ k- _  Z5 v5 dm.appendReplacement(sb, "");
result = m.find();
}
) h  b2 e0 ~. v( l9 X1 ?' `
// Add the last segment of input to the new String
m.appendTail(sb);
3 y7 k; T" K2 P
( I3 R; h4 O) xinput = sb.toString();
5 `/ m% L& r# b( x& W
2 D* u' @  o+ Y9 k- nif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
2 }( W, D! |# d/ |: F}

从文件中删除控制字符

  g- u; I$ @6 x1 U5 O; t2 I0 s# a/* This class removes control characters from a named
* file.
) I1 \6 [" e$ G6 T" D6 M9 V4 q*/
7 w! k5 ?2 Z+ l; E' limport java.util.regex.*;
7 r( D+ v$ @' E# G9 z3 Gimport java.io.*;
9 x) @# z* u1 X; Y2 U
public class Control {
public static void main(String[] args)
           throws Exception {
0 }; E0 e5 i9 _: f9 y+ m- D7 m           
  w2 h# i9 I, h" U; |//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
" y( K! u$ u; ?; \8 P1 `/ hFile fout = new File("fileName2");
//Open and input and output stream
/ @* X+ b7 ]! r" o  FFileInputStream fis =
3 d. L. z! Q1 x4 z) Y8 w       new FileInputStream(fin);
& y% q# {4 g& {0 O6 FFileOutputStream fos =
       new FileOutputStream(fout);
  O5 k' A2 F# R0 w
, X( W9 L* q) W8 bBufferedReader in = new BufferedReader(
& D5 V2 o4 G+ n/ Y& W' \     new InputStreamReader(fis));
% w& \! M- Q  c9 Z0 IBufferedWriter out = new BufferedWriter(
8 G. ^) v$ J0 J$ ~- P; f0 ]     new OutputStreamWriter(fos));
/ k5 e! _( h7 p+ S6 q
// The pattern matches control characters
5 K3 |! R" B! [* k4 BPattern p = Pattern.compile("{cntrl}");
/ m& ~( a' v, x% w! M+ Z) o+ {( mMatcher m = p.matcher("");
% D! W7 }9 f% @! z+ Q5 ~) ^( LString aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
: }: f% X# C! }  B* b& Q- a1 r! n* Oout.newLine();
}
. _" \* U5 C  [  Y; Q( U, B3 f$ tin.close();
: r4 z' n7 m. j  U6 k: Uout.close();
}
}
0 |! j) O3 @% O- A1 u
文件查找

- W$ p2 f' c$ G' |/ x8 ^/*
; r/ X( T) r) D4 n/ Z* Prints out the comments found in a .java file.
- R% c: C% L# N# `( a8 P*/
$ a( F$ A6 L2 C* }6 ~# X9 Nimport java.util.regex.*;
) R3 n" g* g- Y6 Timport java.io.*;
, R7 u. y" z: H! Eimport java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
7 Y; R# C. P- N* T( T. l. N) F
6 e# x1 v8 e. D' l9 Y! U" gpublic class CharBufferExample {
* ^8 c' V, Y$ T# }7 Z: _' x/ hpublic static void main(String[] args) throws Exception {
. d$ M' ^2 X9 e! Z2 g// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
1 O5 F9 [8 ^" h; a2 a' B$ a
// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
% ?1 |( V8 Q& ~; x+ u" rFileChannel fc = fis.getChannel();
  y- Q/ c; I/ e% x
8 N! U9 L( N& b3 T) H// Get a CharBuffer from the source file
ByteBuffer bb =
$ A; E/ D$ Z* q: v4 sfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
. q4 N, i- i5 ^Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
0 \; t/ W& [: b/ H% }! |
7 r* F+ n) \+ K8 ~// Run some matches
Matcher m = p.matcher(cb);
( z5 a: o) U0 J- z, x& Bwhile (m.find())
0 H/ {6 D; |  S) SSystem.out.println("Found comment: "+m.group());
}
}

结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
3 u. t* h" |' W/ ^1 Z6 H
' m$ y' Y5 e/ PJDK1.4之正規表示式
( Z: b/ u* Z9 i( G) x' dwritten by william chen(06/19/2002)

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

, ?! M  u2 R* A; l! f5 @: {5 ~, A1 ~3 \5 y- j什麼是正規表示式呢(Reqular Expressions)
7 i2 g" B' F# p# T5 n  m
" ^0 H3 |& j+ }# P; ^+ J就是針對檔案、字串，透過一種很特別的表示式來作search與replace

# D& b3 F0 L1 g' i因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
. o9 C# `! P0 q$ g: G' Z) Y
% ~2 x- ^5 W* o. T- e$ h3 S4 H所以發展出一種特殊的命令叫做正規表示式

# ]2 L: W+ W+ _$ B6 S, l% L% {我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
1 f/ t$ s8 J% Z8 u" L6 P$ B* N
' R* r& y( t- {) E6 t6 G6 ^3 E若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
# k$ }7 n9 ~1 r9 z5 R: H% i8 b
剛剛列出的一串符號" s/
) n' S1 O; h" A7 S. ^8 V適用於j2sdk1.4的正規語法
; s! {% ~; q! _8 I9 x! }
"." 代表任何字元
3 W) }9 K' }/ P4 h  W& k  ~8 g( C  N
正規式 原字串 符合之字串
. ab a
3 t5 ]( x/ }' {. S& F' ^& q0 |8 t.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
5 {/ G9 A6 i: S' N+ ab ab
( n8 ?0 F2 y2 A1 h; D  p* abc abc

"( )"群組

正規式 原字串 符合之字串
(ab)* aabab abab

字元類

正規式 原字串 符合之字串
/ C7 }4 |; R$ v, q[a-dA-D0-9]* abczA0 abcA0
- X3 P" F3 L  S! z[^a-d]* abe0 e0
8 Y4 _' U' ?/ B& d8 _2 w[a-d]* abcdefgh abab
% V3 ~& h- i$ S) E6 ^* y

簡式
+ f# c4 I1 l" ^5 @0 V
: S- H, i# m6 r+ S\d 等於 [0-9] 數字
6 X, K# O! C. ~! Q# R\D 等於 [^0-9] 非數字
1 m; U4 ]$ j- A) g* d\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
3 ~. J) F: P  ^0 |4 F\W 等於 [^a-zA-Z_0-9] 非數字與英文字
7 o5 u4 z7 h% v+ A  N& E2 t
每一行的開頭或結尾
8 J: B7 A; F- I2 f
0 W' e$ x3 C" G" v- M& c8 d0 J^ 表示每行的開頭
$ 表示每行的結尾
. x0 _, |/ {& A! `" A2 k
--------------------------------------------------------------------------------

正規表示式 java.util.regex 相關的類別

Pattern—正規表示式的類別
( o/ L$ u  F! t6 u: \& ?Matcher—經過正規化的結果
7 I  S, V9 w1 ?8 T5 D$ R' |PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
6 A* b9 ?6 x( o$ }1 [# f, L
8 O9 \8 h+ s/ w2 I- d範例1: 將字串中所有符合"<"的字元取代成"lt;"
8 i( p8 M0 e4 n
0 x; k3 I! T" u+ u5 }4 s- nimport java.io.*;
import java.util.regex.*;
. n# c4 K  y' D( s9 B. A/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
, ?( W# ]8 V$ a9 q' Y4 G6 Y% J// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
0 S: r( Z8 Q8 W% ]0 T. w5 x4 APattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
- y+ u. \, }% \& W! _# }: stry{
while (true) {
7 Y" o5 d0 |- N" h6 yString line = br.readLine();
- h: x( L5 z( ~6 w& m// Null line means input is exhausted
+ N7 |4 {+ _2 H' Rif (line==null)
break;
- l7 Q$ ?3 E: Q3 P/ E! k' \0 jMatcher a = pattern.matcher(line);
while(a.find()){
. y& v! A1 l0 WSystem.out.println("搜尋到的字元是" + a.group());
2 ^$ a- R% Y- h}
9 l8 P" r$ j- j9 n- ~% CSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
" o+ O+ i* a5 ?7 s) `" {8 F4 t6 Z. n}catch(Exception ex){ex.printStackTrace();};
}
  M5 ]. l; c7 f% U
範例2:

import java.io.*;
import java.util.regex.*;
4 }+ n3 G! L+ f' a% F/**
* 類似StringTokenizer的功能
% J9 _) d" M8 ^) L' `; Y3 u2 l* 將字串以","分隔然後比對哪個token最長
9 L6 w, t3 C8 l*/
public static void search01(){
// BufferedReader lets us read line-by-line
8 m  L2 n% n! ]( kReader r = new InputStreamReader( System.in );
6 v5 _+ M4 D: Y6 c4 Y* i) j0 pBufferedReader br = new BufferedReader( r );
- S0 A6 l, S! q9 |4 q( WPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
" L8 F+ _$ G9 U; H) Vtry{
( g' h1 K$ {9 H6 x8 q9 iwhile (true) {
9 M8 f* ?6 ?9 o3 K/ b4 iString line = br.readLine();
String words[] = pattern.split(line);
6 d9 T2 Y4 K5 d$ v, s- Q// Null line means input is exhausted
# w& S4 H. Q, Q$ i/ @* I! pif (line==null)
2 ?% g! P4 N+ |3 `break;
// -1 means we haven't found a word yet
- ]* ?5 m: B8 j" P+ z8 f  |5 z2 {int longest=-1;
int longestLength=0;
. c8 {  }% ~& d% d0 l4 j2 ofor (int i=0; iSystem.out.println("分段:" + words );
. j% G* c+ y( R& I. }if (words.length() > longestLength) {
! e) a+ `! @* |* ?longest = i;
$ J. m) S- i& [2 X# g3 ]0 PlongestLength = words.length();
+ W$ O# K; U5 x* w}
}
/ m# a( Y, e% D7 L6 a" OSystem.out.println( "長度最長為:" + words[longest] );
; y2 K* f/ x3 K3 P) X: I}
4 R6 @! l2 Q: i, c5 P4 I' ^/ k$ Q$ G}catch(Exception ex){ex.printStackTrace();};
}

% ^9 O0 c" R; H% t' X' E4 q--------------------------------------------------------------------------------
8 {, k, C9 T. ?, z- I) |
4 n4 A6 n2 S  V" l9 c5 r8 @其他的正規語法
3 |* A" ~( j0 x$ |5 P2 i, M, O- A
/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水