关于正则表达式---ZT

Longe

第一部分：
, w7 y" d$ m3 p7 c8 m* s# l% ^-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
/ s; ]4 A5 y# K$ C, w2 Z
. T; ]# h) s9 o# C1 x- R, R+ m, Y支持多种平台
. U* R" d4 J) X* d/ w  ?: X* l+ I
6 Q( i( |0 k8 V2 n* c4 y- U
& J0 ^  h8 q3 L3 P8 G" e正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

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

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

9 G& s% X5 Z8 T1 Z% e- |' j正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
! h) E. N  {8 V7 \1 p----------------------
9 q  C/ I. D, a+ B. ^" O字符匹配
  N9 X+ h6 m4 N% |2 n; w! \7 @
+ l$ W3 p+ R  v( H正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

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

Table A: Character-matching regular expressions
格式说明：
---------------
操作：
) \2 v8 \3 L4 N, V+ x& b- z: @解释：
例子：
结果：
" I; U6 t7 i( b4 ]  u----------------
$ L8 K$ s9 \& O7 ^( T' S4 I.
& ?% O1 a" P% l- V" qMatch any one character
* w3 E* ^7 i' h/ \grep .ord sample.txt
. S  y: @) n8 v% KWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
Match any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
[^ ]
' t2 Q9 B$ X$ y3 |* m1 i* X7 W* TMatch any one character not listed between the brackets

6 G" Y3 s1 I3 w+ x6 `grep [^cn]ord sample.txt
3 @. S! y2 X0 {2 w0 H% ?9 U/ _7 yWill match “lord”, “2ord”, etc. but not “cord” or “nord”

4 N5 q2 g' ~3 E8 E. F6 p) ~grep [a-zA-Z]ord sample.txt
" R7 t1 O" U! ^/ a. U$ DWill match “aord”, “bord”, “Aord”, “Bord”, etc.
) |1 p' q" j, f- B
1 Y; T* i- E1 B' vgrep [^0-9]ord sample.txt
: s) v% a" k( |' \( ]- r: W6 XWill match “Aord”, “aord”, etc. but not “2ord”, etc.
! J4 z3 r/ e( ~4 X( M5 A% g1 q* r* i
重复操作符
: G; ]6 h2 L& ~重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
" W! f9 K; J3 j! _: `. ~" k/ H
( c2 K. N/ K6 c7 @* QTable B: Regular expression repetition operators
格式说明：
0 [* W8 q1 d, W) k, _---------------
操作：
解释：
& q! x9 ~' P/ G9 G; M4 \- `6 X例子：
结果：
1 @+ S% |5 T2 U, R----------------
* ]- g. i0 A1 q: @- q" M0 [: z?
: d  g' F5 s, b! U" i0 h; Z( m. ZMatch any character one time, if it exists
! [* j; D7 \/ Y& a7 Q+ I7 o3 Kegrep “?erd” sample.txt
  k$ ]: ]* ^+ L) B  {8 b; zWill match “berd”, “herd”, etc. and “erd”
+ G: G/ Y0 l" b2 M4 q: \7 O- M! U------------------
" p. X/ D( f! \: a% y5 v. q  r+ f*
( |: [! c# H+ E: e& Z2 O6 i8 fMatch declared element multiple times, if it exists
& w1 Y! o! `2 e# o( x: Q0 aegrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
5 B; n) P1 s$ y0 u& U-------------------
' {# V7 S  }% C! Q, N+
Match declared element one or more times
egrep “[n]+erd” sample.txt
6 x9 X$ f! u5 z+ `" {* P3 b0 y5 nWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
Match declared element exactly n times
* u" f. e3 i/ Z1 l; i+ Uegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
9 A& O6 ?5 J6 C" k/ k: y5 H------------------------
{n,}
Match declared element at least n times
: ?$ X1 X; s3 }. ]: k% _1 n) qegrep “.{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
egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

4 u  ^2 E$ v8 N! k) J& Z# M第三部分：
3 T. _: h1 B6 e" H% P----------------
# B8 Z! g0 A* p9 m( }+ P3 f锚
+ |. f9 u) X  d: W锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
' N3 [- ^% B: i2 A# S3 g5 r
; B4 [& L8 i* K% u/ ~( k; p) as/pattern_to_match/pattern_to_substitute/


Table C: Regular expression anchors
  z" |+ `; f- ~" V& x* H  Y-------------
操作
9 u  U) w! Y+ y解释
2 m9 s2 e7 C% J5 |( g例子
- f% ?4 n: S) j* ]4 o' ^- H7 f结果
---------------
^
Match at the beginning of a line
s/^/blah /
. t. \% v5 @2 P' e, ^/ cInserts “blah “ at the beginning of the line
! c" ]+ D: _9 A2 A/ r---------------
3 z5 S  i# Q2 S! H) h& I( m$
* Z; Q0 C6 Z. N+ ?1 ~2 HMatch at the end of a line
s/$/ blah/
  B1 o* b0 D5 B7 hInserts “ blah” at the end of the line
---------------
( J6 @9 m0 E5 e" G5 w' e, J1 l6 |\<
/ n/ E6 _, O9 o) o' Y( O1 nMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word
) Q+ ^' ]6 @  {1 z$ R
( ?" {- F. a! x. p( C; [3 @* {9 \egrep “\Matches “blahfield”, etc.
3 I8 v! C1 s% o7 ^9 O! j4 r; b0 b' A------------------
\>
Match at the end of a word
5 w! O# q! I% S5 u4 e0 E7 Zs/\>/blah/
6 ?1 ^+ @+ D3 _, j* [  W5 Y3 }; EInserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
6 \) L1 U# Z/ z9 O/ l* ~/ C---------------
\b
Match at the beginning or end of a word
9 j( I6 g& N; A2 K  legrep “\bblah” sample.txt
* w- h. m' r' N+ e- f( y& m7 S' DMatches “blahcake” and “countblah”
2 T  _$ ^7 M* P- A-----------------
\B
# U" u1 b: d3 nMatch in the middle of a word
egrep “\Bblah” sample.txt
- W: e& a  t- X% N- {4 g1 Z: u" mMatches “sublahper”, etc.
0 i0 B' O, F; ^. i; f* ^" i
间隔
; X( ?# h" v. n3 y8 W
Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
3 ~# b8 I/ @- `: ?+ O% k) f% z
egrep “(n|m)erd” sample.txt

$ x3 _2 @" x* |  ^% q间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt

; y% |- w6 B, J- W) p; e' Z当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

5 H% `& e9 G  x第四部分：
# r$ e; z5 L" B3 o& ]1 l7 S----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
3 Z# i8 N$ F& p6 N
^ (carat)
. (period)
6 s, y; C2 `: [8 f[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
6 ~! }4 [+ t2 M; ~" D; I? (question mark)
( ~$ y2 `9 g0 `- k) U  }2 A8 D0 [% |{ (left curly bracket, or left brace)
\ backslash
0 o) L- o. R$ d0 s一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

- k* q5 P# u0 Ieregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
8 [& g" l0 p2 N7 j; i" m0 ^$ c0 o* }在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
7 g  i( b/ M  I. i$ K
) C1 T: G2 x1 N/ i! l另外一篇文章
----------------------------------------
正则表达式和Java编程语言
4 F& ?" \& u" m& z+ i/ ^9 Y-----------------------------------------
类和方法

7 Q3 L1 ?) \. k0 z6 I- M+ a2 Y' P下面的类根据正则表达式指定的模式，与字符序列进行匹配。
  r0 [4 ?2 d8 e4 c7 G
Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
: Z) e+ }: g& R
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
$ B+ ~$ D& c& ~8 {% I
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
7 m9 ]! D$ Z) T% I7 i- P7 a* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;
& X  |/ q, \  M3 X& j
2 H( `! X* E6 `& v/ t2 tpublic class Splitter {
7 i4 J: t0 q5 \! |public static void main(String[] args) throws Exception {
3 R% o- A, K& C6 X( J4 I" Z// Create a pattern to match breaks
2 q5 Z$ r4 |5 ~& e# VPattern p = Pattern.compile("[,\\s]+");
5 Z- v9 T* R0 U. c8 d3 F% ]// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
* i# i# }' s* [  tfor (int i=0; iSystem.out.println(result);
" c- G8 l4 g4 D( B- }5 ]6 x2 p}
& a- r1 z1 y( U" u7 {}
9 l% _- O/ s5 M" V! f3 A
/ w% I% X  m( p8 K9 B+ QMatcher类
- \7 N3 i9 X2 }! L
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
+ T) Y' I; k3 ~5 g9 |* y$ Y
matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
- B+ d1 P* x' V' Q  a. h  X  s
7 J8 }' F1 b( D* _这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

7 t4 H' U' `1 a1 l+ ZappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

% `( _" x, P5 W2 H例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
- l) L3 E3 F0 C* y, @2 u
CharSequence接口

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

8 a* T0 A. m9 G- K/ kRegex情景范例
7 B1 X% a0 w' J) D
' I4 @! @/ @2 ^  V! n' D  R以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换

/*
* This code writes "One dog, two dogs in the yard."
' |- y1 U3 v7 @; n/ z* to the standard-output stream:
*/
3 K* F# d! a0 e1 r4 m/ |( Limport java.util.regex.*;

public class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
6 N8 u3 B. p* [! C5 `3 Y! n: yMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
7 p6 X) A6 ~8 U: i  P. z* kboolean result = m.find();
// Loop through and create a new String
2 J, L1 H! m' n+ e// with the replacements
while(result) {
( U; k+ N5 ]" @1 F' _( J4 E  F- Rm.appendReplacement(sb, "dog");
result = m.find();
  k) h, ?6 r( F* G: a5 K}
// Add the last segment of input to
// the new String
m.appendTail(sb);
System.out.println(sb.toString());
; b0 \& ~6 i% P/ G- w8 Y( t}
}
9 X) o4 L( }# u1 O8 B  m9 s
! l# G& D3 Y7 l7 ]) H# n! `电子邮件确认
1 Q/ P& S5 j4 b5 l( m2 K
) n" q% @  }! V' Z( r以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
9 b! T' t8 N8 I% l5 O6 R* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
' c& I  q+ a* `% k) N6 F           
String input = "@sun.com";
$ Y2 F/ K: r$ {7 z- u5 P& B5 I: X//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
. a2 ~' P0 W- q0 `Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
+ ?! C  \4 X$ g$ |5 Nif (m.find())
! U9 D6 B* V3 E; d8 mSystem.err.println("Email addresses don't start" +
" J2 L, N8 j$ q+ x: }0 A2 t         " with dots or @ signs.");
% w# j' w) ?7 x+ V7 N/ M$ k//Checks for email addresses that start with
$ K) A5 {- s" j3 v, A. L1 j! B. M//www. and prints a message if it does.
7 B7 y. L& Z8 w# f& C2 W. Xp = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
4 R# z6 r  g- I7 d  l3 y& H   " with \"www.\", only web pages do.");
}
1 I( i0 Z3 V/ v& E1 sp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
+ e9 u" T8 l2 K$ Wm = p.matcher(input);
; L; Q) A, L, L/ S6 x5 Q& }StringBuffer sb = new StringBuffer();
boolean result = m.find();
- q$ h( D8 V. e8 Rboolean deletedIllegalChars = false;
2 Z9 F6 q( `' D/ t2 \/ F
' z' A( G- h8 p1 cwhile(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
- j* z3 G0 o- w/ |& w, K}
+ ^3 I7 Z9 n$ I9 l9 F
// Add the last segment of input to the new String
1 I; P; `9 c# b, g& ]3 O  Zm.appendTail(sb);
9 H5 A$ ?" \) j  u/ D, I
4 [$ z1 m" i/ h- \: @3 _8 vinput = sb.toString();

if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
% k) i6 [; j0 \}
}
: j1 y, \9 J" G* B( B& q+ S1 n# _! P}
  W0 O- C( @+ ~$ R$ V) P( Z
从文件中删除控制字符

6 b4 J. S7 l) ^9 ~/* This class removes control characters from a named
* file.
*/
. ?/ g! H/ W# `$ }, ~. O" G7 q' ~; oimport java.util.regex.*;
import java.io.*;
: u" L7 h, ]8 z2 u' |" m& @
# J& f3 l0 {3 b; p5 `public class Control {
1 j7 }0 z+ ]1 ]" S- q5 opublic static void main(String[] args)
7 e5 C" v, E$ p. n  F" ?           throws Exception {
           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
( c8 d1 m$ x3 {/ V7 L' ?//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
* L7 J& a3 G' Q7 W8 g: {3 x, M
// The pattern matches control characters
/ T; d2 H. h" K# mPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
- `9 }6 i' H( T9 W0 o1 V5 _String aLine = null;
while((aLine = in.readLine()) != null) {
) p( G- i, c; X/ D( L+ d) Jm.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
$ A% B  ^+ G7 `6 d2 |( dout.newLine();
}
in.close();
out.close();
/ F7 k0 [) D* }- C- w}
}
! c6 x' F( X) v, w9 Y
文件查找
  G1 G6 v: a3 a; [( F5 X2 V1 |( k  J
/*
% m# C. M1 t5 J* Prints out the comments found in a .java file.
*/
, f2 ?8 e3 U0 R1 Q0 K2 _6 p4 ]import java.util.regex.*;
2 T9 d' M) @4 C" F, S! U8 Himport java.io.*;
import java.nio.*;
: i! V3 L8 P5 B0 nimport java.nio.charset.*;
( Z1 R  g! \, U+ O1 ~8 M7 K: ximport java.nio.channels.*;
- v( _4 v" N$ R  n! a5 q
! ?% Q) d0 b$ ^, D/ ]+ c9 W( m3 Kpublic class CharBufferExample {
( J  |& g( L" H7 D, a5 W7 Xpublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
( ?$ {, {! k. w$ _9 gPattern p =
) o  I( x) Q4 j4 `% d$ NPattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
( W2 ^' m( l9 U: {8 ?; _7 fFile f = new File("Replacement.java");
+ L% g3 u) D% l7 \FileInputStream fis = new FileInputStream(f);
! S' }9 C& V! l* \: w6 E; F! VFileChannel fc = fis.getChannel();

& Z! F8 g+ m% \" x: n/ `8 p* E+ O// Get a CharBuffer from the source file
7 J5 g# G, H& U$ w0 p% ^& {ByteBuffer bb =
# i4 {, E) M7 xfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
2 T4 D5 [( f: m* g: O3 q9 q6 ECharsetDecoder cd = cs.newDecoder();
* \" s* \; _( @" G0 ~  K# r0 XCharBuffer cb = cd.decode(bb);

+ J' N( h9 q* ?# p: v8 y5 Q" J// Run some matches
* R/ U2 ?4 [( O8 Y. J8 n+ p4 D9 [Matcher m = p.matcher(cb);
while (m.find())
  ?! a: V5 }7 A. R; iSystem.out.println("Found comment: "+m.group());
}
}

结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

  Q9 U9 b/ C& Y5 r( AJDK1.4之正規表示式
written by william chen(06/19/2002)
& h! G$ T) p7 B9 v  K) B) q
$ a$ F6 D  |& @- N; v--------------------------------------------------------------------------------

+ k+ U( G* @4 g& ^: G1 e4 S( k5 Z  i什麼是正規表示式呢(Reqular Expressions)
$ ~+ t# M. c( {  ^# m4 j; B
就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
+ ^& q  `# G. @" R" R( K4 x
5 U. P, ~2 q  y7 T) B所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
' o1 i4 c: s- w# n因此jdk1.4提供了一組正規表示式的package供大家使用
2 W2 ~/ k3 f, P# Z
6 N( s% d: {* ?, f9 D" s若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

! [" d/ w* h8 ?剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
4 e# `% O& y$ `6 b9 u
+ }: s6 \' r/ O, x0 m. \"." 代表任何字元

正規式 原字串 符合之字串
. ab a
/ {% c& R) |  F7 {.. abc ab

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

" b: i) z5 h; j, F正規式 原字串 符合之字串
* R0 n, e3 l- _; s4 T+ ab ab
/ Z, g) {. _. E6 S* abc abc
8 y) I0 h. w7 t' g2 ]
$ y6 h: y% M: q7 z+ g6 j8 F"( )"群組

正規式 原字串 符合之字串
$ F0 ?; R6 v0 \" T(ab)* aabab abab
+ l! |+ r$ `+ N/ b
字元類
5 v: Z  i& }# b9 i; X
( R$ Z8 J; H: J4 l正規式 原字串 符合之字串
5 s3 Q* i6 h# V4 _' A8 t[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
8 F# A" Q8 a$ W9 U* j9 I8 N[a-d]* abcdefgh abab


簡式
9 P5 c8 K' s+ m+ W7 y
+ e2 b' K1 c# c& [. [! V\d 等於 [0-9] 數字
2 A2 y9 B8 T  Z% V( ~8 F\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
* [, u$ f/ l  N* o5 U. g\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

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

--------------------------------------------------------------------------------
- ?* e; m. V: Y0 s. i! ^
正規表示式 java.util.regex 相關的類別
* i2 \1 ]  P, r5 o# a$ J
Pattern—正規表示式的類別
Matcher—經過正規化的結果
3 @! k6 d6 z2 J: f# QPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
# [" m9 O4 A8 C7 b
  i0 E- M( b4 b4 ~$ {1 m範例1: 將字串中所有符合"<"的字元取代成"lt;"

. O  w$ c, k- N0 F" pimport java.io.*;
import java.util.regex.*;
/**
7 b. Y; W; U5 }1 o* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
9 ?& N2 q- d& a' S/ E// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
/ E5 ^4 I' C' c" ?BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
* B0 k/ N  n9 }: twhile (true) {
String line = br.readLine();
// Null line means input is exhausted
# B( J; i$ e' Q4 V$ }if (line==null)
' C. R' W3 |/ h* ?, G; G* }break;
  a) j1 ?  I* I7 tMatcher a = pattern.matcher(line);
while(a.find()){
  H  E; ]$ I/ l' F' T! q* ^System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
) n: }" j# u# k}
- F5 W# D; t2 e% X. Z( R7 f}catch(Exception ex){ex.printStackTrace();};
' x( ~/ B1 E! z& g6 W}
& B! C% h  F. O8 Q1 y
範例2:

import java.io.*;
import java.util.regex.*;
/**
, v4 P- O# Q; o" k* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
% H- L# P' i4 N7 b*/
public static void search01(){
// BufferedReader lets us read line-by-line
* ?$ S6 S' T" q: w/ X0 v; y0 U7 U% `Reader r = new InputStreamReader( System.in );
7 {% s/ k, h1 X6 \BufferedReader br = new BufferedReader( r );
, [8 C, i& n4 uPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
2 g1 R; x4 O5 `. K/ Rwhile (true) {
String line = br.readLine();
# r; R5 k: b9 t+ o6 E+ Z' e% BString words[] = pattern.split(line);
7 {4 \7 b" \0 q* ?- [  ?// Null line means input is exhausted
if (line==null)
break;
7 l4 N, L3 w1 l6 ]8 T// -1 means we haven't found a word yet
6 l+ D/ s$ n2 {4 g5 dint longest=-1;
int longestLength=0;
* o3 Y! y' a8 s- V$ Ffor (int i=0; iSystem.out.println("分段:" + words );
) L. p. c, l( }; N# Jif (words.length() > longestLength) {
longest = i;
7 ]7 y6 a: T7 L; hlongestLength = words.length();
}
}
7 S5 g0 [) N$ S8 ^  NSystem.out.println( "長度最長為:" + words[longest] );
' q$ p, U4 _, {9 \/ J1 q}
}catch(Exception ex){ex.printStackTrace();};
9 |  I# f. d& A}

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

其他的正規語法

+ u" b8 R8 J2 w; A/ Q( }9 k/^\s* # 忽略每行開始的空白字元
  ^! [+ i) }+ a  z' j; @9 A" w! [(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水