关于正则表达式---ZT

Longe

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

支持多种平台


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

5 a, g7 _) r6 ~" E' Q9 @, H; a1 F正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

* x; k% C" x7 N! j许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
" `6 q# Y$ J' p: M. U+ t( s6 L随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
4 M( a5 @" N1 ~1 ^- }$ o, U3 [
1 ^; x& l6 z# ?4 ]1 b  i$ v正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
2 Y- F" T" `( [1 K' W% p
第二部分：
! s# K) E9 ]- F$ e/ [( i----------------------
字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

每一个表达式都包含需要查找的指令，如表A所示。

; Y9 Y3 s2 e; `/ A2 u3 yTable A: Character-matching regular expressions
; y3 N; M. o3 }! [5 }+ x格式说明：
---------------
操作：
$ b5 v, [* Z0 }7 S6 @/ Y: L, j解释：
例子：
结果：
( `6 R* A' g) J8 v; Q. q0 x----------------
.
Match any one character
! c: g6 e8 \6 {# K% tgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
! e4 w6 J, Q9 b0 j: l# m; [-----------------
[ ]
  N5 F' j1 V! C5 J- HMatch any one character listed between the brackets
7 ]" M6 R. e7 g- ^3 Z: dgrep [cng]ord sample.txt
! B( {) D7 K1 z$ M* fWill match only “cord”, “nord”, and “gord”
8 Z2 n" r' P8 \; Y5 Q" [6 {---------------------
3 l' d+ w' o& K! G[^ ]
Match any one character not listed between the brackets
3 @& X# b! ]+ y4 Q! s! @1 W
grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

; j+ [* {" i' e- J# M% {grep [a-zA-Z]ord sample.txt
, O+ N. k" C/ R8 d5 J5 f. r5 zWill match “aord”, “bord”, “Aord”, “Bord”, etc.
2 T' l  C" m/ c. R& b! H' k
) j, V/ \0 i. n/ c& Q  y, F0 Sgrep [^0-9]ord sample.txt
, m& }3 x) K4 H' C3 p$ [Will match “Aord”, “aord”, etc. but not “2ord”, etc.
/ Y! Y: p) }. ^  f
重复操作符
" }' X; t. z( Y重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

0 N/ }: l8 Q( O; ^& rTable B: Regular expression repetition operators
格式说明：
' E3 l. _8 o. W( a- _+ J---------------
操作：
) V. h6 J* D1 ]0 L解释：
例子：
* H. D+ q7 l" \/ g! p结果：
----------------
, `% q) N* d, w+ y?
Match any character one time, if it exists
5 q8 F; G5 ?+ x! a; begrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
# e7 U0 g, V8 p- Y' ^' W" [------------------
*
Match declared element multiple times, if it exists
' Q$ a+ \8 n1 a6 Q# @% v# iegrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
/ P' b$ J: K4 G2 e+
Match declared element one or more times
egrep “[n]+erd” sample.txt
6 @! f  \8 x$ ^, Q2 |# l/ TWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
+ b% j( Q4 U. c: |{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
) W6 X2 S2 X+ q6 U------------------------
{n,}
0 }( E& C: j0 d. h% x& [Match declared element at least n times
- f8 _2 O7 D1 C; Z/ Legrep “.{2,}erd” sample.txt
2 X+ x# O1 p: F3 OWill match “cherd” and “buzzerd”, but not “nerd”
- I% }$ Y3 s/ f  r9 g! i- J& _# T0 N------------------------
. x- S% P3 g" ?' ]3 b7 L{n,N}
6 m* j* E. }7 v/ V7 q( \Match declared element at least n times, but not more than N times
. N9 l. k6 v4 Eegrep “n[e]{1,2}rd” sample.txt
% J" @- j3 W# c/ P& R8 FWill match “nerd” and “neerd”
3 }0 [, \! ]6 ^- F9 W& F
" q0 ^' C5 ]1 _4 z& A! O& T第三部分：
& a% Q6 d  F  N$ [; s5 z----------------
$ g& O, B9 v& ~5 e  w' n锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

. J" r" N* g" f+ c/ v$ r; ss/pattern_to_match/pattern_to_substitute/


7 p  c) P# G- e7 m: q0 iTable C: Regular expression anchors
* H1 r2 R9 j" V* z; z* T-------------
操作
: U% A, x# V; i% R" f解释
2 Y8 ]& H5 M5 o5 b6 Y例子
结果
$ y, M- J# u6 |) r---------------
+ f4 N! ~& N8 b% ^^
Match at the beginning of a line
) |& I& }8 [9 l7 ks/^/blah /
Inserts “blah “ at the beginning of the line
/ {# e. g5 v, a; F---------------
5 D. s, N5 G2 r" q. p! s$
Match at the end of a line
$ ^& {( }) ]2 k2 H2 h0 v4 x* S: s4 o5 V4 Rs/$/ blah/
Inserts “ blah” at the end of the line
---------------
4 O, i( H! ^' p7 J0 ~1 Z% k\<
/ U5 N% r5 l2 Q( ~  V+ q3 w' |Match at the beginning of a word
1 M3 n/ F9 k$ a* x% \( C% o+ Os/\Inserts “blah” at the beginning of the word
; S8 w' J3 Z% a  Z
egrep “\Matches “blahfield”, etc.
------------------
\>
Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
  t0 _8 p  A" g( F
/ }+ ^6 b' N! A: B  s2 Oegrep “\>blah” sample.txt
! N) T+ {0 A7 V. A' c4 l  B& cMatches “soupblah”, etc.
---------------
  x" j2 }1 T  \$ p7 Z! b\b
Match at the beginning or end of a word
  ^+ O7 a- i2 c" [- Kegrep “\bblah” sample.txt
# s3 P* {, P# ]4 e, S! LMatches “blahcake” and “countblah”
-----------------
\B
7 g+ Q7 N' T& J0 x8 ~5 Y: e- H; yMatch in the middle of a word
egrep “\Bblah” sample.txt
) P8 r9 |( ^4 N8 uMatches “sublahper”, etc.
; \2 W3 m$ |" X) N. k9 @
& U1 e  h6 R* J, G* }3 ]0 c间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

egrep “(n|m)erd” sample.txt
. L4 i! O/ p: [
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
0 l$ W# |1 |/ w- B5 z  A
7 X3 S7 j/ `9 N. Oegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

% ^  C6 Z: p' n3 i第四部分：
----------------
6 @. i8 T# Z4 f5 L( ^一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
( |6 H; t" Y* ]& F1 q
1 i/ }. y# o' J$ O( Z: f^ (carat)
. (period)
+ f6 t  p8 n6 @: t6 f, S4 Y; W[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
/ o- B- h2 ~& X" H9 U( g7 f  a| (pipe)
8 b8 T2 b+ x# N, B: s0 u* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
6 C4 _$ y0 U8 `\ backslash
  U% @8 D# M$ v  e8 Z3 ]  a$ H* ]一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
& b, ^* r/ Q0 d% p& w& m
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

( K( l- p4 S6 _/ |( |你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
# v# v- G0 x: H! M6 J
总结
* i3 \9 V1 |- B; D/ `+ t! f在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
* T# E" C. ?4 x- A----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法

6 {( @- Z7 R$ w下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
: [7 e1 R$ f" [8 f' x7 R+ X" s
/ C% x3 h! B6 S3 _  M, s& g' lPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

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

: J: }4 t6 h3 d! S$ v9 E, s用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
" a# w* y, w! M+ e: C% V& S+ G$ \
2 B; p4 @+ D; X# c5 g5 T% Xsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
8 E7 f/ `' S5 E( J& R$ S
8 {+ N2 U, _- Y/ W- X/*
. B( d' K7 b: @* 用split对以逗号和/或空格分隔的输入字符串进行切分。
2 a- c2 E8 M: w& p: Z' r*/
; f0 ^+ r  y8 Timport java.util.regex.*;

public class Splitter {
public static void main(String[] args) throws Exception {
8 E# b! @; y6 x9 Y4 S9 Q// Create a pattern to match breaks
* o& X6 C/ E/ {: r# M' iPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
9 ^; @. m5 y1 x" l0 ^- J, K* {String[] result =
* E* ~8 d% G1 X: ~+ P# v3 j, Y   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
& y1 X! d" U# J3 |}
8 t6 f4 e( K8 Q& Q5 Y}

2 Y+ f) s1 m6 C- I- tMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

+ ^, \8 Q3 ]$ e" `( l通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

2 S7 L5 b3 D) H' c3 Imatches方法试图根据此模式，对整个输入序列进行匹配。
# o+ u" n2 A& c) vlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
; E( r7 S: I7 ~! c( G9 b) p# E) o
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口
1 w+ t5 U" w% M8 L
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
$ x4 U( I, ~1 M# x
Regex情景范例
: y; C  c# z( L  L% K$ q5 q& ^/ a
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换

* D' F# @* N5 E& u$ E/*
* This code writes "One dog, two dogs in the yard."
; h, f* b+ h! S6 \. A* @5 L* to the standard-output stream:
*/
1 S9 k# C1 N2 V& `+ G  ]* cimport java.util.regex.*;

public class Replacement {
! {, K& y+ H( B$ e* j! v. opublic static void main(String[] args)
; [3 g8 u/ L# @8 B0 g; e2 J; k! X       throws Exception {
// Create a pattern to match cat
6 F7 e  }7 ?$ P- f. k( i; g/ APattern p = Pattern.compile("cat");
5 q- m5 z2 Y( {& X// Create a matcher with an input string
  x5 j% b' v8 _Matcher m = p.matcher("one cat," +
) u1 h' B1 P5 ]3 b     " two cats in the yard");
& q) y' _' i! c0 o8 Y6 J3 m: [1 mStringBuffer sb = new StringBuffer();
boolean result = m.find();
7 ^1 j% _0 l, ~" K// Loop through and create a new String
// with the replacements
4 |0 V1 O, r; }6 _( @while(result) {
) A3 Q6 _7 J7 a. o; A0 Fm.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
0 ?9 @6 S) |0 c3 v3 m; lm.appendTail(sb);
% Y/ d+ ^3 F" s3 L, {System.out.println(sb.toString());
}
& l7 \9 j, }1 r! a5 H, z}
9 V0 ~4 R. b. F" v* O/ E, Y  }
电子邮件确认
  ]8 f8 q. j; q
9 _: a  D6 P4 U* K4 m) s8 s4 S以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
& Y; x: }. }" B7 @* [* `- w% n
: T9 n9 A3 Y) V! D* }9 j( n/*
+ y+ g; U! }* Q. q" \' i* Checks for invalid characters
* M' ~6 t$ k  V# X* U( V* in email addresses
*/
public class EmailValidation {
+ F$ e1 a, c, upublic static void main(String[] args)
1 p$ l+ y) o8 n5 ^           throws Exception {
# Y" [& v$ w5 x: m9 W, z           
- v7 m" q) h5 z7 NString input = "@sun.com";
//Checks for email addresses starting with
) y6 d& _/ F: ^0 t1 n//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
; V7 Z  Z4 D5 _4 WMatcher m = p.matcher(input);
. [2 E8 }5 K/ f3 r. S. Jif (m.find())
" f* @/ {/ h- j7 B2 @" r6 USystem.err.println("Email addresses don't start" +
* k$ m+ D6 V, @         " with dots or @ signs.");
- j5 y  J$ Y1 k//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
0 R! Y! O2 |8 u6 Y. ^2 E9 Em = p.matcher(input);
% l7 p% k6 {( ?5 N8 j- v( Rif (m.find()) {
  i% @0 [7 [; D' hSystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
7 N; v, ]! Q3 m$ w" Ap = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
0 ~. M: u1 S: T0 k2 j+ mm = p.matcher(input);
) P1 j2 r4 F! mStringBuffer sb = new StringBuffer();
# D6 E  _6 r7 [* f6 U3 ^1 K) w+ jboolean result = m.find();
boolean deletedIllegalChars = false;
5 G; H9 x& `6 j1 e, }& `/ X
6 W& m5 {# s4 M  hwhile(result) {
* c* p5 _( x) ]( I5 I5 X2 E: R  KdeletedIllegalChars = true;
m.appendReplacement(sb, "");
: U, l% U  e8 Yresult = m.find();
}
7 m3 e/ t( ^" _- C* L& k5 C& E
// Add the last segment of input to the new String
m.appendTail(sb);

input = sb.toString();
# E  H. y& \3 i+ D8 B9 O/ F+ K+ ?( a
if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
4 ?% ~4 W: y1 [" }       " , such as spaces or commas.");
}
}
}
6 Q& p7 K9 d; ^- Q( {
从文件中删除控制字符
9 O, o9 W' A; N8 j/ |
/* This class removes control characters from a named
* file.
1 k* Q8 q5 w% K* N*/
import java.util.regex.*;
import java.io.*;

% T# ~( ]! F, y9 a. tpublic class Control {
; \7 z, i6 h7 {  f; {" d* t# cpublic static void main(String[] args)
           throws Exception {
: W$ C' q/ O9 `+ f; C. B# W  r- `           
, p0 r" {% M) @. u* l# O//Create a file object with the file name
% f' Y4 y$ A% {& K, N+ U//in the argument:
; A  N0 ~9 s9 EFile 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);
1 e8 p; ~# K7 P- `: l4 @3 v
BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
- q% [2 c& c$ Q6 x5 X: z     new OutputStreamWriter(fos));

7 ~+ ^5 G3 K5 Z5 l3 V( q8 ?( N" J* U// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
& Y# C( N6 Y8 U: t: P6 P$ s# uString aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
0 g" _9 Y( e& I% ~/ @2 z# l6 FString result = m.replaceAll("");
out.write(result);
& U9 W, O' S+ [1 |2 q( Zout.newLine();
}
in.close();
; O+ f9 ^, L# C% p3 ^4 O5 |, vout.close();
7 s7 l6 u% p# ?! n9 P2 n}
& u6 V3 u7 N  R3 E1 ^3 P  R8 V}

文件查找
5 p: k9 q) y: X" U" ]% t0 ?: p
' Q, M1 W; d4 d* n- h/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
0 F- U3 O- e8 aimport java.nio.*;
import java.nio.charset.*;
0 |. D2 R9 \" n) Fimport java.nio.channels.*;
/ |; Y7 l( J: Z9 u
public class CharBufferExample {
6 ~& M5 y2 P0 l: u( vpublic static void main(String[] args) throws Exception {
/ _9 A' R5 _* `4 E0 D. u# N// Create a pattern to match comments
Pattern p =
5 P( g; n: a9 @% v! SPattern.compile("//.*$", Pattern.MULTILINE);
# e* C6 u& y9 k0 o4 u, B0 T% K; y: w
: C0 H+ ^  v+ p/ E// Get a Channel for the source file
$ d. I! m$ b* @5 a$ ~7 `: eFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

+ a1 Z, O# R7 D. r& g6 d* K- t// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
9 v5 F" \; Z' d- @CharBuffer cb = cd.decode(bb);

3 w! G0 X( A/ m8 y+ G: k6 q// Run some matches
$ U0 r# v3 V8 ?/ b. U+ M0 v: Q( ]Matcher m = p.matcher(cb);
9 O9 I8 \3 T! w6 T7 s: ?while (m.find())
System.out.println("Found comment: "+m.group());
}
5 g1 A. a; G( R" X  G8 D$ T) L# T6 P8 t}
7 l% Z7 G3 k( b7 B
结论
) x+ m; [, f! a现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
6 @; [6 G2 w* U2 q' e; I) o$ t+ P! A" F& Owritten by william chen(06/19/2002)
8 ?, J% Q: S* Y0 }8 B" C+ c  E
7 l* U! p# d1 M. x5 s, G; G--------------------------------------------------------------------------------
, R! \/ w) d) C
" f  S1 e" |% m" U! M' r什麼是正規表示式呢(Reqular Expressions)

就是針對檔案、字串，透過一種很特別的表示式來作search與replace
& V* d# z6 P2 N
4 M8 ?$ E' b5 Z$ G因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式
& ~* z1 @$ Q" ~* ~( d7 y
9 {+ [1 I9 }1 s4 C* n6 @2 [: d: K我們可以很簡單的用 "s/
' H5 F( ]* P7 i因此jdk1.4提供了一組正規表示式的package供大家使用

0 l, t3 j5 C: x! i5 l若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
- B' i1 E& y2 ^) t適用於j2sdk1.4的正規語法
9 p( i# J' r  V( R6 `
/ K( c" Y3 @$ Z! k& b$ w* @"." 代表任何字元

正規式 原字串 符合之字串
0 U3 Y' U8 B6 \. M' I) I* H/ w# B. ab a
.. abc ab

"+" 代表一個或以個以上的字元
; x2 j) {8 G! n. `"*" 代表零個或是零個以上的字元

( ^" P& r! O+ r4 q; m- q正規式 原字串 符合之字串
+ ab ab
/ ?6 v8 h( M7 H( ^* abc abc
! ~6 V: h% m& y( O; _' b! h" N
"( )"群組
# x1 h# ^( p" b5 Q6 m% D1 \$ \4 j
. [* f6 e% R) ?! k6 q0 Y正規式 原字串 符合之字串
- J) n2 u% {/ O; M, y2 b8 h(ab)* aabab abab
3 t" |8 Q" s6 L6 l1 n- L, A/ J7 d
字元類

正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab
9 s2 I% T" H+ L8 H" u

$ u3 u: ~/ F# `, p9 W簡式
# t) J5 ~& x7 T4 V& {6 _' H0 v
\d 等於 [0-9] 數字
) O* R- q; G) @# ]# t7 n\D 等於 [^0-9] 非數字
3 n( Y1 q, g! E: r$ s\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
: z  [( X/ J3 ?* x+ A$ W- s\W 等於 [^a-zA-Z_0-9] 非數字與英文字

) w  J' N# n* {4 M% P* h每一行的開頭或結尾

^ 表示每行的開頭
$ 表示每行的結尾

7 V9 ?$ y$ s0 A6 m" U--------------------------------------------------------------------------------

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

Pattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

範例1: 將字串中所有符合"<"的字元取代成"lt;"

3 ~" ?! I, Z) yimport java.io.*;
import java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
( n) z4 W7 m8 y7 b- t/ b) [public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
: l  h; h, o2 t2 F. v8 rtry{
# k6 b2 b3 \) Z/ y# {' I- owhile (true) {
' \) C$ M  k( {0 {5 H. s' g: CString line = br.readLine();
( Y  C7 a+ L6 z// Null line means input is exhausted
9 W: U! p6 p) fif (line==null)
break;
7 X6 N; C2 I$ ^8 CMatcher a = pattern.matcher(line);
. U8 F" b% L9 G# |1 O* Gwhile(a.find()){
4 w; e8 e9 K/ I; t' r9 E1 |System.out.println("搜尋到的字元是" + a.group());
}
" B, G; l9 r3 y8 M8 P+ l" G7 o6 e3 oSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
  h5 L6 \/ }" P, V$ o3 i6 X}catch(Exception ex){ex.printStackTrace();};
}

範例2:
) w* g! S# r; O/ x3 n0 @
" ^8 }. V+ l& r9 ]0 r. s' dimport java.io.*;
$ {4 p- v" [. P: e: S1 r, D& L  |import java.util.regex.*;
/**
; w" G" Y9 K' K  t. H/ j* 類似StringTokenizer的功能
3 W5 ~) ]0 l& w" D9 v, S5 o( ?$ y* 將字串以","分隔然後比對哪個token最長
3 B  x( t$ L: ], F) F*/
public static void search01(){
4 `* P- Y$ C" [+ G' Z0 J8 O7 M// BufferedReader lets us read line-by-line
+ Z+ y8 T0 {) J/ z( y0 f6 v' ]Reader r = new InputStreamReader( System.in );
( ?) Y' h1 \8 h; D: M) WBufferedReader br = new BufferedReader( r );
% R* M( @/ R5 Y, ?& tPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
String line = br.readLine();
1 S& {* }( N& R. F/ d' L, dString words[] = pattern.split(line);
// Null line means input is exhausted
) u" ]) [) P- n: g0 K: ?' bif (line==null)
break;
// -1 means we haven't found a word yet
0 B/ y& r7 Q+ ~$ c: d9 i- Tint longest=-1;
- n; Q' F0 m; ?& K4 G% f* w* V& bint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
longest = i;
longestLength = words.length();
- g7 |4 l, o* T, H2 z$ R3 G# [}
' h" \5 ?6 y. f- z4 Z, e# u/ |  I}
9 ?( w- b) m9 t1 tSystem.out.println( "長度最長為:" + words[longest] );
4 G5 m# A# S, i, c4 n% L}
}catch(Exception ex){ex.printStackTrace();};
}
' E2 S) o$ l5 {
--------------------------------------------------------------------------------
# y% O3 B+ \. }) y4 S1 s; S
其他的正規語法
; }5 h+ ?3 V& @0 E0 f, ]
/^\s* # 忽略每行開始的空白字元
1 ~& o3 h& ^. d/ X  T(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水