关于正则表达式---ZT

Longe

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

. t; g, S2 o8 M# \: Z& p3 ~' \支持多种平台
4 r  k% _5 J9 r
" ^& |* |2 }# T: u6 g; ~
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
. i& g9 ^& X3 ~/ ?3 @) q
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

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

比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

( J+ J0 \* z. S4 Y' M. J& A正则表达式101
* X8 D' i; p$ ^, ~7 }很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

0 k$ N2 N. Z. k4 y第二部分：
0 {2 _+ t  O8 y, U2 m----------------------
8 V* v1 Y! F/ K0 _/ R! P字符匹配
: i# U, ~7 x& J9 S/ |" y0 F* Z" E
  M2 {: s1 _+ @正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
+ f8 [, L4 w! H# b
# f( h. N9 d+ P8 q) m+ A) U每一个表达式都包含需要查找的指令，如表A所示。
) @- `0 a( K) c$ a( s1 i
$ V: c  k! B9 ^Table A: Character-matching regular expressions
格式说明：
+ `4 M& r8 m2 H, [3 I& K" s+ n; ?---------------
' ~- N7 E- j' R- E- h$ n, Y6 l操作：
4 ?) L+ F& P: C4 O9 r解释：
例子：
' H0 P6 n+ R! k1 I" t结果：
! v: T  j' {' J! `- p: H----------------
+ k3 u! o; {, ]3 A4 T2 }; p.
Match any one character
9 x; ?# b. Q+ r: n0 i2 d1 lgrep .ord sample.txt
! @* C6 S: i  dWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
Match any one character listed between the brackets
! [$ k6 {) B  ?/ i) r: ~- s/ Ugrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
- t# X( V, x7 m0 c' x---------------------
[^ ]
8 Z) E5 f% w- i9 m& pMatch any one character not listed between the brackets
2 G8 g! I- c  B- W
, E0 r) S# ]0 H) U8 v' W' {! G3 ~. s0 |9 Jgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

3 K# t. b$ \  R$ @* J' {: f: S6 sgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
+ w) p& b. i/ i& n
grep [^0-9]ord sample.txt
: ~8 S# F; Q% @Will match “Aord”, “aord”, etc. but not “2ord”, etc.
- ^& e' i" u- m# _% ]3 h
9 S3 k$ j4 j$ f, t重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
; R8 n+ r# u8 w: Z  ]: c! N5 n格式说明：
! ]9 Z4 F$ y$ s7 I0 J1 K---------------
" x- p  [; J9 P1 W操作：
解释：
$ T# h$ S* D# u* M) z例子：
, y- S: B% @5 z$ \" g  a1 z1 l结果：
" B/ C; {- J9 H----------------
?
Match any character one time, if it exists
8 m1 t' i* V4 ^3 Eegrep “?erd” sample.txt
' c5 b0 i% B1 I  X: s9 RWill match “berd”, “herd”, etc. and “erd”
2 H% z1 Q4 O4 O7 i: ?  a------------------
: I# @- x5 i/ o# T9 ~*
Match declared element multiple times, if it exists
0 s; K: W4 ~! a( [% \2 Segrep “n.*rd” sample.txt
( e7 n0 c6 c" m8 L' yWill match “nerd”, “nrd”, “neard”, etc.
5 B  b" ?9 z1 v) J/ }+ t-------------------
% {( {8 N7 D$ y5 h* `4 R  L% S+
, d/ q7 \7 B. {Match declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
6 X  N. W0 w) [2 m- {3 y--------------------
{n}
Match declared element exactly n times
% H0 G3 e9 d; b0 q% u  z) Degrep “[a-z]{2}erd” sample.txt
% L7 a. z  v- I( UWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
% a- E" |) S# B' A8 J, z0 L9 X' `{n,}
* k/ W2 f' U  I) |1 G( U3 lMatch declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
Match declared element at least n times, but not more than N times
1 \. N; ?% n/ {4 ]' u4 ?egrep “n[e]{1,2}rd” sample.txt
- ^9 E9 t5 ?/ \; QWill match “nerd” and “neerd”
- r3 d8 h) w8 P: A6 j" X7 l6 U
第三部分：
) z# Y, J4 y# s5 h5 `----------------
0 L" q5 Y0 y& N- a锚
& B  M  q+ T- d7 o3 Y+ {锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
6 {* u& ]1 s7 Z/ _* L% ~. g
5 l  l$ p+ F  g! M: K* S6 Xs/pattern_to_match/pattern_to_substitute/

9 r1 U* V. p; ]* e1 n
Table C: Regular expression anchors
-------------
操作
! c$ {3 f( s, J: ^解释
例子
结果
---------------
^
Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
$
/ S/ [: x  T3 {3 [, Q8 S) F& \4 UMatch at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
( }) {4 ?- x7 e! d9 V& `& w1 o# Y---------------
\<
Match at the beginning of a word
9 L1 q* `3 i5 ~2 a" m* Y; Us/\Inserts “blah” at the beginning of the word
" d; F0 A! O, C; K
6 K0 b% ~1 k  ?, B9 I- o& oegrep “\Matches “blahfield”, etc.
1 p$ @6 W  \/ F------------------
1 a) i2 J" H: G  k, W2 H# h2 y\>
$ Y1 E1 N+ z1 @/ S. U1 `0 DMatch at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word

+ ~. J9 E6 ?  R1 Iegrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
# F5 W) y, s5 ~9 v\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
  k4 X5 b- n+ m& D5 H8 QMatches “blahcake” and “countblah”
-----------------
\B
5 ?$ g$ N) q+ Y7 w3 z: a+ XMatch in the middle of a word
egrep “\Bblah” sample.txt
& T" Y* T6 e* E# w: e: d3 PMatches “sublahper”, etc.

" G( D4 n" D* l, Q间隔
2 E( _' I$ x" G0 W% a
5 t+ I$ Z' X/ g2 U" f* l! g  s3 ]Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
5 W8 u! }5 ^  S! F
egrep “(n|m)erd” sample.txt

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

egrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
. v- r1 C6 P* `3 j# a( `& D
9 M( J2 |6 `1 D. I/ a0 p( t第四部分：
! ?$ ?6 C; C+ F" o; _: }& t----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
. (period)
; F  x) L0 v7 b) H4 n( v" s* S[ (left bracket}
% F* N7 p  W7 I* c7 N. k- t( b& _$ (dollar sign)
( (left parenthesis)
+ w7 t5 e) b7 m) (right parenthesis)
5 f1 `6 i( X4 V& m6 H$ M5 S7 e| (pipe)
5 i9 f$ Q' Z! U1 G* (asterisk)
% z# D9 h( m$ E& a# w+ (plus symbol)
& v% k" {0 e& J& m, A2 K- r& G? (question mark)
! k- }1 J) I+ G0 ]" E# g1 w{ (left curly bracket, or left brace)
1 U9 l! `% ~, y, N\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

2 R; L$ `3 c! Q5 i0 Neregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
' q# N( T; C( V$ x; o) n
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

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

另外一篇文章
, c4 R1 }. d3 A& H7 U5 W----------------------------------------
正则表达式和Java编程语言
: ^" s3 z- y; D4 C-----------------------------------------
类和方法
8 D/ w# D' ~# l; L, L, a
+ \  S/ Y0 ?) }$ F下面的类根据正则表达式指定的模式，与字符序列进行匹配。
  [7 Q' l6 M" h, l# T4 P
  W3 P7 E, V" w. j' }2 f- NPattern类
$ d6 d+ c) I& F) P
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
9 N1 E, j0 ]2 n
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

7 S; g, u9 @* T! y, }) w用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

0 w. U* B: l/ O: }- Lsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
+ N) R' r% F) A, r8 ~
/*
; s" d( f7 n7 B+ n* 用split对以逗号和/或空格分隔的输入字符串进行切分。
3 z' Y- y, |  d1 K*/
, D  _" M4 `0 w2 h/ e9 w9 h! Limport java.util.regex.*;
! j2 z3 I" L6 r% `/ d7 s
) d0 ^8 E! G" @1 E  ]5 M" s6 k8 Hpublic class Splitter {
- K( J% |, W7 z+ upublic static void main(String[] args) throws Exception {
3 `6 Y2 I+ ~5 {3 p7 r7 k// Create a pattern to match breaks
  Y  P6 I3 Q1 F; I7 E. K; b/ e4 [Pattern p = Pattern.compile("[,\\s]+");
" t; y( h0 z6 U0 T8 F// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
+ O% l, k6 o7 H( H; }: rfor (int i=0; iSystem.out.println(result);
}
}
7 J5 k1 ~' F; N
Matcher类

( r# }. Y8 [2 h4 l% S" t' `Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
) t( @& _5 G( l9 j+ olookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
# r- D: ?' x) `9 nfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

' F! g# `5 Y4 J7 B5 M这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

, p9 E$ ]/ V7 E2 h; n9 i9 u这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
  w0 ~4 u; S2 K* ^) |6 }/ Q& N
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
( v8 ~( r9 |, {" z
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
1 |) J) _, c' ^4 E; l
CharSequence接口

. |4 l8 {1 b; ICharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
7 Q# b& S$ X4 j) M& i
Regex情景范例

# `& n( E7 c, Y! [以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

2 A8 |( v/ _9 J5 ^. h3 k8 ?- |5 h简单的单词替换

/*
. ^& h" T8 R1 N, V" O7 K2 K9 M* This code writes "One dog, two dogs in the yard."
* P" N: C& R8 z! f* U* to the standard-output stream:
*/
; y5 c- b( C* G) _import java.util.regex.*;

4 k+ L- e/ X# C) `2 ipublic class Replacement {
. r! t6 _6 ~. V8 h& G+ ypublic static void main(String[] args)
7 X3 Q" e+ K5 _( q       throws Exception {
3 Z. V$ n. f1 L9 d$ b" h// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
  w; J0 p' G' s% ?& pMatcher m = p.matcher("one cat," +
) q3 F2 u, L- K* x! ^     " two cats in the yard");
8 x! D) g+ g+ `, i) gStringBuffer sb = new StringBuffer();
$ m" V; y; ]: _2 lboolean result = m.find();
// Loop through and create a new String
  i' M9 T  R. `' [' j9 f' t// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
& Z, ^* S8 t2 U: H0 W- O7 f6 Q}
// Add the last segment of input to
// the new String
m.appendTail(sb);
: t/ G6 G: @  m" i1 j% k7 @8 ?System.out.println(sb.toString());
}
}

电子邮件确认
: z0 Y% Q" w& V* q. `% N5 R
9 N4 u4 w+ J9 f. X: c以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
) S6 A- Y, B# m+ X; v! N
/*
" {# m) i& u2 Z1 X  @/ `* Checks for invalid characters
* in email addresses
" v$ ^7 }, @) W- }1 ]*/
  ]) w4 P0 r8 L( [$ t. \$ ?- ]+ \public class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
//Checks for email addresses starting with
2 ^) T$ Q/ u: f# t//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
0 [6 @+ r6 E/ y# i' Rif (m.find())
System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
) u3 m- ]* m- Z. c4 P7 M//Checks for email addresses that start with
2 A3 I0 E% p5 L5 O//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
6 H: B' E4 [& d- M* L  d9 l- ^m = p.matcher(input);
) n$ C' H/ w, M+ w& R$ cif (m.find()) {
/ @6 t" M* m: b( m  _System.out.println("Email addresses don't start" +
- x4 v  j1 N( X6 r( D% {% z7 z. `5 _% ~) B   " with \"www.\", only web pages do.");
8 O8 ]3 R) w6 t6 m) Q}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
( }6 e6 @' }$ M+ sm = p.matcher(input);
  `  _; P* L3 t, p! sStringBuffer sb = new StringBuffer();
+ _4 D. A) g7 Tboolean result = m.find();
+ R8 A' ~) d1 P2 Q5 L1 Tboolean deletedIllegalChars = false;
' t9 J" ~; J8 Z5 H
1 a0 G0 Q  Z4 |8 f, rwhile(result) {
deletedIllegalChars = true;
; l6 {3 T/ `- l4 M. a+ Qm.appendReplacement(sb, "");
4 P: B" f5 X2 y6 J4 V* |result = m.find();
}
" b7 r" q8 x$ R# Z  y6 R+ X
' B# G( ^/ b) I// Add the last segment of input to the new String
m.appendTail(sb);
5 g3 @0 h7 a6 }% m7 {9 U- q9 S* D- s
* @! a9 o- O- U3 d5 K2 @input = sb.toString();

if (deletedIllegalChars) {
/ U, H7 }/ J7 Q7 n8 B' R* p" E( pSystem.out.println("It contained incorrect characters" +
  {0 M- s4 I6 k* h6 e       " , such as spaces or commas.");
}
3 f3 X( e5 U6 A7 M, Y8 l}
3 W& |  R: q6 }; g" |}
: B' V1 D2 y% s* M, W" E" m
从文件中删除控制字符
& K- x% p9 ^* ~0 b7 g( N9 Q# O" M
( U% h9 Q" p' y0 s/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;

% j# e! H; |; V3 [6 A# R& c% X/ |5 Ppublic class Control {
* X" `$ L" L* e3 s% t& npublic static void main(String[] args)
           throws Exception {
/ n6 i& ^4 F  c" ?3 _* o( S+ v           
. S0 {( G/ _- V0 S" F+ o//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
! k& w" E4 Y$ W$ N, B: m9 n9 M- JFile fout = new File("fileName2");
& ]& N& S: i# e/ a6 n, L//Open and input and output stream
0 r+ G0 p% Y+ |  p# c$ K% K6 R8 eFileInputStream fis =
" N/ ]' d) W, U4 Z  I! @: j( {       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
) Q/ }; q/ ^  j- z
+ O, l, j; [5 ~( wBufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
2 v7 a# x6 N$ e8 ]" x+ O# b     new OutputStreamWriter(fos));

& f; `6 A1 n  b// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
; L% f* R. j+ ~+ O6 I. w: tString aLine = null;
* F- O& `7 {; D0 A2 Q  K! zwhile((aLine = in.readLine()) != null) {
. }# E- v% R0 _9 U$ am.reset(aLine);
" p9 n3 G- ?" G4 }. Q& `( E//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
8 f: r* P+ K$ y- q}
* ?5 ~8 Q, K( min.close();
+ _4 Q3 t% u: \  jout.close();
}
1 z& _- o' i& n. N4 e+ B  f}

文件查找

/*
4 ?- Y! p# a8 D* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
9 ?& ^; ?5 V5 C4 j- jimport java.nio.charset.*;
import java.nio.channels.*;
" V6 r8 p0 r. g3 H7 H  h4 J/ ?
3 x! Q' M8 l& Q1 ~$ spublic class CharBufferExample {
( C( D# G, f" x3 `* kpublic static void main(String[] args) throws Exception {
- c  j: N+ @5 R  e) r; k( X// Create a pattern to match comments
Pattern p =
6 U2 j& c( I" }* u$ ]Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

1 P* K& Q5 S8 x" F- q! \// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
" L9 H) B8 g! R$ HCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
' I3 b6 S8 s& e7 y: C, r* n% H( SCharBuffer cb = cd.decode(bb);

// Run some matches
7 p+ g- c  w  H" q4 dMatcher m = p.matcher(cb);
2 g) n3 z9 M: b5 a6 {; @while (m.find())
0 K3 s, L% @' W9 P& @# FSystem.out.println("Found comment: "+m.group());
0 H' T0 g! l7 E5 s' ^3 T- q}
}

结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
+ t* P! o) T% c9 W
8 @9 j; p7 [6 kJDK1.4之正規表示式
4 Y& e6 K' P2 g7 J( g6 Dwritten by william chen(06/19/2002)
* m5 P! @& p8 Y' W  H2 c4 d
--------------------------------------------------------------------------------
. v+ W9 a& R2 I  |( J
什麼是正規表示式呢(Reqular Expressions)

* I* z* U4 s5 ~0 r# k' P/ U7 Q就是針對檔案、字串，透過一種很特別的表示式來作search與replace
) w$ d/ P& Q3 c+ K- ]6 q6 P
2 U+ e# E# T6 _& J7 K% J因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

. s: W/ F# W  B, ^, I6 _# d+ @所以發展出一種特殊的命令叫做正規表示式

& y5 i5 J- S+ Q( y- D* Y' F' T我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

2 A4 O$ x5 _& u3 v0 T4 Z. T若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
7 E7 v2 Z7 r$ D) n4 ?/ J, K: l
  D! A. g1 t& c剛剛列出的一串符號" s/
; K( A# V+ Y# n' I( s8 J* ]: h適用於j2sdk1.4的正規語法
5 N# B( o1 |  ~$ B3 o2 x5 B2 w6 G$ Z
0 G4 N4 L' p  j/ A! r0 f"." 代表任何字元

5 r" `3 u8 c. B  \7 p$ |正規式 原字串 符合之字串
. ab a
.. abc ab
5 A2 ^% b& e, [+ e$ z" L$ t8 o0 p: K
"+" 代表一個或以個以上的字元
' `9 h/ ?( H: A"*" 代表零個或是零個以上的字元

9 J4 z/ z$ ~$ I* n) F+ m正規式 原字串 符合之字串
+ ab ab
( i4 {8 y% Q0 V; t; S7 N: G* abc abc

- z! h, s0 k" i9 P/ E% U1 b! {"( )"群組
' A8 n  R7 L- K& P: q8 B, F
正規式 原字串 符合之字串
(ab)* aabab abab

, \% l" `, j. g* Y7 {字元類

4 j8 T0 S" W$ k& y4 |正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
$ g4 Y9 M/ ~7 l. W/ ?' b! ^5 [[^a-d]* abe0 e0
- P5 D7 k1 `9 s) X/ m# B& v8 E% [[a-d]* abcdefgh abab
. u( f6 b8 |  k2 I" i4 r7 ^

簡式

\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
& I  l0 l: X' P
) Z# q0 i! C3 v5 j! x( u每一行的開頭或結尾
$ Q( {$ a( O' z2 U% \* K
7 W; W4 ?  N" H; U7 \+ ?^ 表示每行的開頭
' u# V' l( u. c+ v: A8 z* V5 e$ 表示每行的結尾

; U1 a6 S4 B* |--------------------------------------------------------------------------------
8 X/ |: ~5 O: Z
正規表示式 java.util.regex 相關的類別

  x# [6 ^& a# v* ^, f1 w# XPattern—正規表示式的類別
Matcher—經過正規化的結果
- {" X% t) M# M6 m2 e6 kPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
- ^8 _2 F& B. ]+ p: Q
" @2 X' K) S) D% W範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
$ C2 ?; p6 F' i; Z- {5 Bimport java.util.regex.*;
/**
# Y& ?$ f+ E, f9 E) t( o. b# Q* 將字串中所有符合"<"的字元取代成"lt;"
*/
$ k! `8 O8 v7 J$ a  \2 Lpublic static void replace01(){
8 d) \! p6 o' a' m3 Z/ G# b1 \// BufferedReader lets us read line-by-line
, G; U9 W# m+ c. MReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
  G: N6 ?' V, `Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
# P1 d( R- o1 ?while (true) {
String line = br.readLine();
// Null line means input is exhausted
if (line==null)
, l9 C6 K# K/ V& l; hbreak;
; e- M: ^, ?9 i0 b9 bMatcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
' ^' o- C* e  ]$ a) I# b- t}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
: M9 K! `8 O/ e$ v2 Z}catch(Exception ex){ex.printStackTrace();};
2 K4 C, d' v( Z) g* J* }}

9 t! t) C) \+ Q8 Y範例2:
$ p; p! u, q: k$ J8 Z7 v9 }
/ p$ @2 p( A' O' K( d' Eimport java.io.*;
import java.util.regex.*;
/**
# V  Y+ m1 o  Y& L$ L) u3 F' ~* 類似StringTokenizer的功能
5 ~5 w5 m% ^( e- L* 將字串以","分隔然後比對哪個token最長
*/
" I% u8 ]% M, J& x! Lpublic static void search01(){
2 p6 Y! }: ?+ g& j// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
/ ^+ d+ L6 Y( e. }% B7 @BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
  r$ I1 L6 i* y( x& xString line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
# A/ @: A) k; k1 g1 Q& n: l# |if (line==null)
! a) R; ]7 ~# X. J2 ^- O; mbreak;
8 i* W, v% @) H// -1 means we haven't found a word yet
- P6 N' j& v; Y  d2 F( Sint longest=-1;
int longestLength=0;
- ^% {8 c4 U6 s# W# y5 M. X# Ifor (int i=0; iSystem.out.println("分段:" + words );
  X" y: j. }: B# p5 ?if (words.length() > longestLength) {
- X! I$ l, }, J* b+ q, `0 Ulongest = i;
: x$ B+ F9 H0 D" v9 LlongestLength = words.length();
' n' S1 y- [/ a& h" s6 N}
& ?$ n2 ?" [; x5 [- e8 N}
System.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
}
; R9 K, J* [* T" Z
--------------------------------------------------------------------------------

% l/ q. G9 T" `$ C. Y5 x/ K其他的正規語法
& X: W' L4 u" a4 x/ p
% ~8 \3 a; ?- D+ {/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水