关于正则表达式---ZT

Longe

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

: C- ]: z. _! O0 Q支持多种平台
# {! H5 s$ E# ^, t  q8 V

9 a4 {0 l% Y" s1 f8 P正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
2 l- v7 i$ \$ r7 R7 Z. J
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

! R3 a/ F6 p2 M1 T1 \许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
& q% I% n' L; l6 `
6 W: ?9 [; W0 R! F2 ~/ x正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
/ m* G6 j! S9 k8 |- _1 G
/ {4 g% z! W4 P( s3 c' ]! r2 _第二部分：
2 X/ U4 y: k' p----------------------
" l: v/ L7 `% G字符匹配

( u, M+ A" u+ V+ ~正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
& L" a) c4 D7 E
每一个表达式都包含需要查找的指令，如表A所示。

Table A: Character-matching regular expressions
& g: B1 r- o& D, [格式说明：
% ?) j5 X$ H+ ?) W---------------
4 S, i- ^* D  q操作：
2 R2 c5 G6 b- H" m2 ]0 M, f5 G解释：
例子：
结果：
, }% o2 S/ D7 ~2 k3 A6 W----------------
/ u5 H# W, L2 N4 {.
3 F/ h4 }; _+ B) |Match any one character
8 V. X1 Y) n! d, r$ R% x2 s1 |- x4 ~+ ]grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
4 U* t+ ]; u- ~% i5 s-----------------
[ ]
8 r! s9 ]: t* S& b, t" oMatch any one character listed between the brackets
grep [cng]ord sample.txt
; b/ w9 o# F# g; iWill match only “cord”, “nord”, and “gord”
( n' n# {4 L( L) H3 V---------------------
[^ ]
2 G8 q- R( x3 t8 \* f! gMatch any one character not listed between the brackets

# S7 S% B1 _$ G1 T  lgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

9 t' n! ?' n3 cgrep [a-zA-Z]ord sample.txt
1 j; O" t& @3 R( }' V; s1 c3 MWill match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
: D+ U/ h5 D3 y9 `6 P
: G$ y( d& p1 @- c& z重复操作符
% @) N+ X' G  Z- o" \重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
& v2 f4 @* c* I" h5 o
Table B: Regular expression repetition operators
格式说明：
---------------
操作：
解释：
例子：
结果：
/ g% n1 b1 ~+ t1 [1 u----------------
?
Match any character one time, if it exists
" t0 ~* j: X0 |egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
8 u8 U9 Y8 T5 k6 j6 ^; E! j% d# l------------------
*
* z  r4 q6 L0 F7 eMatch declared element multiple times, if it exists
8 F' x. _/ O0 C# ^9 oegrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
# o% E8 c, A, g, p+ c& w9 O-------------------
+
Match declared element one or more times
: w+ q3 h# Y# G- g* i$ Y7 oegrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
& Z- u: D, c( z9 V3 e" }8 w--------------------
- P$ |" V% g; s0 D{n}
  I, ]" o8 w7 n4 I( h7 H9 A5 h( dMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
. ]' i1 U) U8 D' {) v( p------------------------
{n,}
* \0 T7 ~+ U& t. EMatch declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
5 u4 Y2 j. S$ c5 L4 [- \' O4 Y$ B0 e{n,N}
Match declared element at least n times, but not more than N times
2 t, y3 J6 Q4 c1 aegrep “n[e]{1,2}rd” sample.txt
6 @# O( k) {- A" p" uWill match “nerd” and “neerd”
. P# g. h. S& t9 ^
第三部分：
# m' w, y; ]9 g/ z6 k- d/ o+ x: [----------------
) w. m' K# F, m, q+ V9 P- h锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
& h0 {" e3 w8 _' b) ^
s/pattern_to_match/pattern_to_substitute/


( M  Y! U9 A2 K* u' J" X8 ZTable C: Regular expression anchors
; W' b+ W2 |( X1 ?& Z( w7 Z. E-------------
: @+ d3 A/ N- N4 S6 P( M; X操作
8 Q0 \# w  {2 f5 y6 S解释
7 k( \, E. a( a* f! v/ [# Z5 Y例子
( z' }* v* j' g  _6 X7 t" M' ]结果
7 W5 K7 Z2 C8 n& @5 Q) I( K. i---------------
^
Match at the beginning of a line
3 i% K; p% P$ V( A# h+ Q* g3 y$ Hs/^/blah /
Inserts “blah “ at the beginning of the line
6 I5 X3 w2 s) g1 x1 d3 {0 F2 f---------------
$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

& ?7 I( H' H& e0 f, i1 begrep “\Matches “blahfield”, etc.
: h0 L# |5 G7 v2 X------------------
\>
- l8 p5 h, S& l+ ~3 mMatch at the end of a word
/ m- v9 w! L5 A, r* H( p5 qs/\>/blah/
Inserts “blah” at the end of the word

0 d* O$ X7 T( d) P- Xegrep “\>blah” sample.txt
3 J. t' `' f; j1 f" V/ b6 MMatches “soupblah”, etc.
! s% ^( z/ ^" z/ t# [5 y2 F6 F---------------
\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
2 H8 n3 x* }  ?: Q" A& z2 j( OMatches “blahcake” and “countblah”
-----------------
\B
: b) i( }0 |( N! ]  p" r! YMatch in the middle of a word
egrep “\Bblah” sample.txt
/ J6 X% }% Z1 l8 F% DMatches “sublahper”, etc.
& K0 M5 W2 ~& S, S
6 ]# ^2 e  w  U6 U) ^, Z' I间隔

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

egrep “(n|m)erd” sample.txt
( \7 {3 h; a* A$ K  A
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
9 O; U1 K7 N6 A! Q  W
egrep “[nm]erd” sample.txt

9 h6 G& p/ p1 W& Y' X4 X+ \4 @当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
, `# j8 L" \$ R' y! s; a
* a/ ]1 v, o, P/ @第四部分：
3 I4 o' }! u* P! ^: u/ J/ ?----------------
一些保留字符
0 W7 {/ m" x9 @Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

: B( L, W: B, W2 V6 X( e^ (carat)
. (period)
4 k) @' w4 i! K# y. ]/ W[ (left bracket}
$ (dollar sign)
% a( m0 I' k2 N8 w0 D( (left parenthesis)
  s- z; @0 B0 L& W- Y: N% z) (right parenthesis)
| (pipe)
* (asterisk)
% {" u5 F+ t. D+ (plus symbol)
? (question mark)
, F. j' @3 m9 w- W{ (left curly bracket, or left brace)
\ backslash
) L0 r; k, l( E% {) [1 S一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

! s1 v4 }) J8 \1 L: j$ R# q% Neregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
, ]+ H$ t$ \  V2 Z+ e5 C9 {
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
& W2 l/ s8 d1 }4 a2 w& h
总结
0 Q% R4 G, P4 O, N$ ^* p$ f在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

. w' U3 c9 @2 z4 T3 q另外一篇文章
----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
( |/ e- M; I* [$ T2 S类和方法
) X! U. V) V. r. _; X) y% p6 f
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类

2 w1 M. c0 p0 iPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
3 K. u$ H3 F/ T+ R& e
2 p% n7 A( h  T$ w7 a) r! k用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
9 K0 r$ M' Z, L/ m
9 ?8 F- m4 g# P; i8 d8 N用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
, I# s0 _8 u! [7 Q9 |; o0 B3 H
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
% [, V" H# I" `$ |) C/ ^# u
/*
0 s4 k  R8 I% r4 f7 N* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
( q/ g5 A( }- R$ @4 }import java.util.regex.*;

public class Splitter {
0 ^" ~* C6 \+ B. f' fpublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
, V+ f5 y! [9 vPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
, Q3 x# F0 @, HString[] result =
) D$ Q3 s7 u* M   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
& A" K& \8 v9 X}

% ?2 {3 z" z" D) Y* G8 C3 uMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
% ~* X8 w7 B( O' i6 z( O" D, s
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
1 W" p, v  ?4 ^+ Z
matches方法试图根据此模式，对整个输入序列进行匹配。
( L. L  U5 _7 r1 N# t% I/ P, |; blookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
9 b# T: n- m7 L, o% P# e+ S
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
5 ]! T# [2 L1 j* X% C$ X- q. p
$ v4 u6 }5 k. k这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
4 H8 p( ?/ q9 L* [
5 B* J/ P2 Y' W% KappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
: P% }4 |. i4 l2 M1 i* I( n; W, S8 z
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
. g) A& {7 I, I" S5 V: Q
CharSequence接口

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

Regex情景范例

8 h$ {+ y2 B2 O& [- T以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
! E9 G1 s. Z, _0 [- ?/ u
/*
) b. {+ K; D& Y9 M( Z* This code writes "One dog, two dogs in the yard."
/ I4 \$ G/ F1 Y! x' P, L: t* to the standard-output stream:
" o0 @+ I: w% l" E8 l*/
import java.util.regex.*;

public class Replacement {
public static void main(String[] args)
* V7 i4 f( u* q4 z       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
3 U; o9 g  N; U& M/ R! E// Create a matcher with an input string
) m; q+ z1 s! O0 h. {$ o* h# gMatcher m = p.matcher("one cat," +
4 \  Q7 r9 A2 m4 h/ W     " two cats in the yard");
. |: A: n0 P- t7 A9 XStringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
2 D, K2 q0 A* E9 H$ _/ x* J( E// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
7 R$ D6 c4 z0 ]7 T/ R5 ~  sresult = m.find();
}
! Y% ^/ ~( [8 I5 r  a% |* o9 N// Add the last segment of input to
5 t5 ^) q- I3 R; X+ p// the new String
2 Y" h/ h6 _5 h, l, F& ?& sm.appendTail(sb);
4 f! z( K7 A8 ~, `; O/ y  j" p+ YSystem.out.println(sb.toString());
}
}

# l7 `/ Y1 c, E$ q4 g# }/ ?电子邮件确认
5 F; {9 e9 K" P9 g+ a
0 }7 N$ x8 E% e1 q  M6 g. a以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
! |( V& f! C' M" ?; g2 n& S+ \
4 N" Q. I8 G: c  r7 W3 W8 ~( X/*
* Checks for invalid characters
0 }' H! Q% R9 q! x* in email addresses
& M' ]5 i# y- n. T: o*/
$ H/ g3 a. e4 c5 U/ V7 wpublic class EmailValidation {
public static void main(String[] args)
: s6 w. B7 ^( c; p1 K( j( j7 w           throws Exception {
           
( ^( t7 ^4 M2 L0 P) }/ dString input = "@sun.com";
3 `7 n1 R* y: n( p& ]//Checks for email addresses starting with
1 R8 L, u' b4 _9 \4 F. a' v8 x//inappropriate symbols like dots or @ signs.
9 K4 E- Z9 v. n) S: C! sPattern p = Pattern.compile("^\\.|^\\@");
4 b5 g; f( H- p/ `4 T! N0 I' GMatcher m = p.matcher(input);
8 O' w# q% ?0 T0 z4 `8 f0 V0 P+ ?if (m.find())
System.err.println("Email addresses don't start" +
$ O/ B2 e. z. v( t; e+ b         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
$ W! ^% y" j/ L+ s6 Zm = p.matcher(input);
) I/ R( \3 w% j& l$ W6 m) ?: fif (m.find()) {
System.out.println("Email addresses don't start" +
1 c( k# n' X9 j, \' S1 y   " with \"www.\", only web pages do.");
7 |" A2 V5 ?- [% N9 C' z}
7 B9 H$ Q0 X, p: e! p/ z1 w8 Op = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
/ f' c4 s: g5 ?( VStringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

: Q8 ~2 u( g9 z) z+ }! zwhile(result) {
/ v8 b) d0 P) [4 |) V, @5 f7 Q2 ?deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
. l* P* e, h7 H8 D}

# i! |) b) n1 o7 p// Add the last segment of input to the new String
5 D. g' f$ }  w1 {m.appendTail(sb);
  t' l+ U' K$ ^
# b% q: b' W- b0 S3 Uinput = sb.toString();

if (deletedIllegalChars) {
% s! s' V' j! w/ ?System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
  d4 }- L) c2 x0 M6 X}
2 X$ L# Z% }. T}
6 x3 X/ B. p' @}

从文件中删除控制字符
  B# I' E) p9 z" v, {
/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;

4 i9 Z5 f( H1 |  n( ipublic class Control {
3 a3 K5 P" W# e* k- g+ q' Y$ j, M' E0 Xpublic static void main(String[] args)
           throws Exception {
+ o6 ^# L. L& ~1 W           
+ n5 X5 @  V  @$ [  @; H$ b//Create a file object with the file name
//in the argument:
$ r! K, k- J) N8 G: R% k- r9 H+ N  rFile fin = new File("fileName1");
, W% N+ ^& O5 ?$ q3 J. tFile fout = new File("fileName2");
+ X* K/ O' e' v% i8 v//Open and input and output stream
# ~9 q# T: r  _FileInputStream fis =
# R3 [" q6 b; E* h/ w# I       new FileInputStream(fin);
8 p# N, B4 j7 P/ K+ Z1 GFileOutputStream fos =
       new FileOutputStream(fout);
1 ?' V  N/ a6 }5 s  G( v# y
* |2 ?2 ?7 R/ E# s1 Z- EBufferedReader in = new BufferedReader(
( x" g0 U( `2 H% `5 l* {9 y- |( z     new InputStreamReader(fis));
9 W2 o$ M3 u# O  V0 |$ b& sBufferedWriter out = new BufferedWriter(
2 I) Q. Q' r* X4 s( M# a     new OutputStreamWriter(fos));
# G6 m' K2 w" o) H" o4 L' f
% l" R9 \* d; T) f% T& B  J// The pattern matches control characters
2 D. p  J4 I2 T5 NPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
$ B0 h: v3 Y9 S. L3 UString aLine = null;
0 P: Z1 |6 H+ v6 e9 ~while((aLine = in.readLine()) != null) {
' g5 ^# @& b) r! |. o8 P7 u, f0 `m.reset(aLine);
! K! B; m* M$ l% }: s//Replaces control characters with an empty
//string.
5 w! s3 q& v, ?String result = m.replaceAll("");
out.write(result);
out.newLine();
5 D' I" ?" A2 F' }1 o}
in.close();
1 q' S& V+ A/ y) ^& V2 R) M1 k; a, Sout.close();
}
}

* U; S& H; ~) c文件查找
/ ~. G5 Y' a7 b; A  X" X, |% [
/*
" }1 u/ P. a2 E4 b: G* Prints out the comments found in a .java file.
*/
1 w% z6 Q, v# \, D* timport java.util.regex.*;
5 t8 i5 V4 d: g( simport java.io.*;
. j7 w% Y; A2 F& T" H* l6 G( Aimport java.nio.*;
- N" l* a0 k1 F6 G8 ximport java.nio.charset.*;
: Y2 H% x* U0 `6 Y0 J' K. z* ?import java.nio.channels.*;

public class CharBufferExample {
public static void main(String[] args) throws Exception {
, Q% T* C5 i& k0 |' s1 k3 z6 ?// Create a pattern to match comments
, f* `( Q: k& H/ N% U0 [9 E# JPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
0 t' O" B6 w$ }% t! y) K5 W
// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
& D/ j( f5 U  s) ~- D; IFileChannel fc = fis.getChannel();

// 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();
CharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
) a& H) O( D7 I& k( {" \while (m.find())
System.out.println("Found comment: "+m.group());
}
5 ~2 r& x2 [' u( l1 r. i1 E}

结论
! @$ B8 }' t8 A- m! A& S4 R现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
  K) V+ u! J# E- l  ~
& s3 u( Q& o$ ~2 X4 u. PJDK1.4之正規表示式
written by william chen(06/19/2002)

/ C7 i( F2 E! F+ q--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)

/ E: \( X% ~$ `* W就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
4 c1 f' s  N' o+ f- h  F. q& x7 Y
( Q$ ~& v1 G6 B5 [+ s0 u+ f所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
) |0 n; N/ h3 n3 c7 d4 W因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
! S1 T. r" R, X
9 I* D7 \9 J1 d* s+ F9 n剛剛列出的一串符號" s/
4 n% b! g: B. V適用於j2sdk1.4的正規語法
# ]/ P1 o0 A( U) M: X% f0 B1 M5 {
# j3 j4 H" P6 j3 Y"." 代表任何字元

正規式 原字串 符合之字串
# ]2 D; C% Z. G, U. ab a
4 ~% _# X; ?/ S( M; t- d.. abc ab
* I4 S( J7 t. s( w4 D* E9 y
% H5 B/ M' q9 @$ ?"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
" p" G% W% A; \$ h1 [- H5 f4 ]
正規式 原字串 符合之字串
9 X/ f& z% g# |! `8 m, @7 Y9 l( N+ ab ab
( H/ \0 f9 ]9 T0 f8 ?# O- I- j* abc abc
9 g) L6 K/ z3 a7 ?1 S# t# h
6 W. V) v) b8 I8 z) G7 M$ t& k"( )"群組
9 S% J( l4 A2 ~$ G
$ o* ^( H* ?6 X% q5 l正規式 原字串 符合之字串
3 h6 N: y  B, N) \3 q8 d0 Z(ab)* aabab abab
1 a) T, Y1 t  j% J5 z
字元類
7 u9 y4 e+ J- Q' P
+ d" b7 e  j* g  t9 E, A: F正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab

9 y; [) F3 H2 v# I# q3 A9 w
簡式

\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
5 c, x1 ]/ }4 b3 N% N0 J\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

: \- f, q9 V) Z1 [& b2 Q每一行的開頭或結尾

: s* R+ N+ A3 Y5 i# |) [9 Q4 [4 Y^ 表示每行的開頭
7 D9 U1 k' x; `5 B  \1 T7 P$ 表示每行的結尾

# L! @( t  t$ b' Q--------------------------------------------------------------------------------

正規表示式 java.util.regex 相關的類別
- ^4 }0 N  p' u% Q+ f9 ]7 K/ T
Pattern—正規表示式的類別
5 O  W- o) _' H( _/ ZMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

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

import java.io.*;
6 G; b' z8 o# D9 K/ ~- ]1 uimport java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
2 s; w* s! l' A) O6 t9 N& U* Ppublic static void replace01(){
& j( `: l0 t; I* h* ^, X+ d// BufferedReader lets us read line-by-line
% e: s6 X/ }! D  W/ \- x$ A$ zReader r = new InputStreamReader( System.in );
: x- z* o/ j6 e# w' wBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
% c: x. B0 D- [try{
1 R! y/ {6 c' E/ r% [- F  [6 o2 hwhile (true) {
String line = br.readLine();
// Null line means input is exhausted
if (line==null)
' [/ l4 `9 g- U$ [" [& Y& ebreak;
Matcher a = pattern.matcher(line);
while(a.find()){
& H8 f: P% }! M  h/ z7 ySystem.out.println("搜尋到的字元是" + a.group());
! g/ i8 G* K" X5 l5 W}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
* T! |5 Z3 q) j, N- v, F7 _}
}catch(Exception ex){ex.printStackTrace();};
7 A8 {& l, q: |( z  c}

範例2:
& a% ?* s/ H, L0 Q
9 |! A4 W& O8 ^$ Simport java.io.*;
import java.util.regex.*;
/**
) ^8 t3 W7 ?: u# x& ]4 `* 類似StringTokenizer的功能
- ]8 j, i7 z* ?: h* 將字串以","分隔然後比對哪個token最長
" a, n2 x" H! u: m. D! y*/
public static void search01(){
// BufferedReader lets us read line-by-line
/ {# ~- n/ Q/ q: qReader r = new InputStreamReader( System.in );
7 b$ O5 n; k( ^2 P& L$ i. QBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
0 ^% \/ \% t6 S% e) O$ n) u7 A& W# qString line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
$ X# n1 o3 P- P, J( ~if (line==null)
  ^4 e- S+ c( w7 c% I/ dbreak;
// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
! }# Z: T7 D! a6 nif (words.length() > longestLength) {
: t" x0 S! z7 y  clongest = i;
1 w, i; i0 E  _0 S5 BlongestLength = words.length();
" ~: n2 h( v# s5 f}
( k, @: b  H, `, m/ G; S# k0 D}
System.out.println( "長度最長為:" + words[longest] );
}
8 Q$ R9 y5 a  d4 N2 \/ C}catch(Exception ex){ex.printStackTrace();};
, N* N" G3 r" r. M$ ]}
+ U' b5 \1 v$ j) E- u6 E
--------------------------------------------------------------------------------

( ^& L1 G. B9 E; w( u- S其他的正規語法

2 B4 H) Z; J7 `# H/ n/^\s* # 忽略每行開始的空白字元
  r5 Q# e; m/ n7 d  ^0 H& z(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水