关于正则表达式---ZT

Longe

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

支持多种平台
' ?2 B% R  |: z) @) j: ?/ h

- j" V6 T5 w( c( T+ _2 H+ ^正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

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

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

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

. l- x- n1 C8 }: q" D0 P正则表达式101
1 ?- Y. |4 e7 l  V4 g& c/ S& L很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
5 I/ B% n1 [7 O3 T5 M----------------------
字符匹配
/ u4 [8 @, w- y: ?9 o+ o# W: I
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
4 K% r& _9 g0 L' |) J$ Y
每一个表达式都包含需要查找的指令，如表A所示。
5 z5 u+ o% L8 g" P
4 M8 X9 }0 f* hTable A: Character-matching regular expressions
" d0 k: p1 O' v6 K. W2 D* k6 v格式说明：
+ i% R$ H6 }' J; x# Y( f$ D4 B. \---------------
操作：
; [' u4 L2 L7 K8 q3 k解释：
例子：
9 F! e. M8 a8 G- b$ o% C' ^+ |结果：
$ d' C0 ~/ g5 w, }! T) v----------------
! @: x; W  G; G% H3 p& s" n9 j.
' L0 x9 v" a. x- zMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
1 a$ K! m" u3 n8 e. ~+ i-----------------
$ L, Z: o# @4 E' B, i  `( l[ ]
! q' H6 a: c4 L8 T3 jMatch any one character listed between the brackets
1 D/ e" I9 B4 E  W8 C+ E+ X: j5 xgrep [cng]ord sample.txt
, A! d# m& v  G# W% X0 @Will match only “cord”, “nord”, and “gord”
; _2 P- g* }6 U  r9 f. T---------------------
3 G0 ?- F* [4 ?3 S5 Q9 L$ E  F[^ ]
Match any one character not listed between the brackets
- K: {3 J4 J% u7 q# P* o& o" \. ?
grep [^cn]ord sample.txt
. v) g8 q# l, z0 o9 }. a+ z5 o: FWill match “lord”, “2ord”, etc. but not “cord” or “nord”
, }) T' y0 D% M. B1 N& r; \8 o
: M0 v& _$ \& U) d: u0 N$ vgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

2 E6 g" s! o) v' B+ {- B$ O2 m( Wgrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

& K* G/ ~( [& }" ?) E+ X重复操作符
; Y# y( t' A+ D8 ?* }' u2 x( Y; [* I) m重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
7 K, P( F& T' n! P格式说明：
0 X  P5 O, e0 s# o& S* U0 w---------------
0 \$ p/ d$ z5 b% m4 H4 O. n1 A操作：
) ?5 _& S- w/ W6 X' z6 @9 g解释：
  g- \/ {0 A; B- m" b, |4 R例子：
结果：
----------------
?
( j0 N3 \: P2 `/ o  |2 wMatch any character one time, if it exists
egrep “?erd” sample.txt
- I7 M# {9 I. i6 @Will match “berd”, “herd”, etc. and “erd”
------------------
*
Match declared element multiple times, if it exists
( [3 M7 `" M/ O! Hegrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
+
Match declared element one or more times
& W/ \2 k  L+ W: h. r+ B8 Legrep “[n]+erd” sample.txt
" m1 X9 u3 H9 ~6 b$ {3 |1 pWill match “nerd”, “nnerd”, etc., but not “erd”
$ K4 q; ~' M0 E2 z9 y6 G--------------------
{n}
+ f! B+ v# h3 [4 V& G8 t2 _- VMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
5 u6 N8 B# l. \{n,}
Match declared element at least n times
" q1 w4 o, b3 N0 uegrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
1 b% b; @% j; q0 \+ \2 ]7 d) E% w# _Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
5 a0 ~* I( w* ~1 o" @Will match “nerd” and “neerd”
; _  j) T: }: E# e2 Q
6 A5 a9 d. x# |, X6 s6 G4 L3 Z第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/
2 w4 ?3 `) c. l4 S: N4 i
+ y* K' k' Q, I6 n& Q
Table C: Regular expression anchors
-------------
! \7 \( ^4 i. l操作
5 i! b& L* n$ t2 M解释
例子
! n0 N3 h8 {& H; T; I结果
---------------
^
4 K7 `- R- s' l1 m4 O  UMatch at the beginning of a line
s/^/blah /
8 r3 G( O9 m3 W5 i$ D' U  M, xInserts “blah “ at the beginning of the line
---------------
$
' k2 z/ x, y$ ]$ ]! ~) g, F* A* h) oMatch at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
. q- S& i. f4 z+ u$ w---------------
; c/ w2 J+ R# U  \2 G\<
7 P. |) m" v5 r' Y& @2 {4 AMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
8 s5 v; W; R7 F/ w\>
Match at the end of a word
s/\>/blah/
' }& z# W8 R9 g& P4 g( b, h) cInserts “blah” at the end of the word
: B( y, M: y6 D6 T. F
2 P3 E) i2 a2 |5 Legrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
; {1 ~4 T+ u6 _1 V$ m\b
Match at the beginning or end of a word
( U3 K6 z' b# T3 e* f- v- |egrep “\bblah” sample.txt
) n) P6 q8 k0 v5 B. E5 JMatches “blahcake” and “countblah”
-----------------
6 l# b. G0 v. |% v5 P\B
; D- G6 {9 C" J' iMatch in the middle of a word
) F, l5 G6 Z) P3 Degrep “\Bblah” sample.txt
Matches “sublahper”, etc.
' o# K* H/ ^: z* }/ H8 ]& t
  H7 o* k  i- u* O/ S  q4 l' Y间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
' |. Q. i2 {1 d4 C+ a  O
egrep “(n|m)erd” sample.txt

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

$ t9 V8 ~! ?$ S- Kegrep “[nm]erd” sample.txt
6 q. G1 O( z3 P( a# \" \
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
4 q+ I# n1 ?, q& P8 ^
7 a6 {% H$ |" P1 U; R4 ^' p第四部分：
----------------
9 `; H+ x- _( N& L2 _* {. G一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
# l4 }9 G8 R3 C% J
^ (carat)
& H9 A( S6 S7 c- p. (period)
8 j$ Z' x, S/ D+ [' i4 s' A0 X[ (left bracket}
$ (dollar sign)
) M% Y. B! U0 ]( (left parenthesis)
: x4 U$ l# i' V' F) (right parenthesis)
| (pipe)
) v& Z# V; N9 B  u* (asterisk)
+ (plus symbol)
? (question mark)
' _  M  O4 I  B  P5 b* S4 K% ~4 ]{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
- u1 Z9 _% a/ `+ k# e1 i2 i
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

, w8 L2 S3 k; b5 N; r( E$ G你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
! S* s9 o5 h2 o- G
另外一篇文章
----------------------------------------
! Q1 M9 q. W+ _& u; I正则表达式和Java编程语言
-----------------------------------------
+ V+ e3 y( W+ n类和方法

下面的类根据正则表达式指定的模式，与字符序列进行匹配。
% Y. S% v9 V/ A( V3 `6 _3 s1 q
Pattern类
3 U7 X$ i0 [6 Q1 ]
+ J3 P. {' c/ x+ A! f* D* A; QPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

0 I( [2 ]+ d& c/ w用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
8 m. q- r8 T3 \" K6 b0 @7 z
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

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

/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
4 x1 s8 I* G, S- R' @import java.util.regex.*;

public class Splitter {
' I# {. c3 K: A! c3 c$ Epublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
) B4 Z0 q  k1 j8 j3 j+ h// Split input with the pattern
/ i# G( ?. y  f& s5 V/ C& Q' ~String[] result =
   p.split("one,two, three four , five");
) t+ @5 B$ x: l0 ]for (int i=0; iSystem.out.println(result);
1 O- T. `5 _7 d) h6 {5 o}
) i* m7 r  @6 P. F}
  `0 n: Z: W6 E  o2 [9 g3 z7 c$ L
( Q: C/ x8 N. k. R+ p! vMatcher类

+ {- c" C. Y* E! f9 h' I1 j, [Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
# t- X, y  [& j9 _
: B0 `: l# F6 }  ^6 g% ?' H6 i& C, z- {matches方法试图根据此模式，对整个输入序列进行匹配。
4 n* D6 E+ Y( C' W  Y, Q9 b" p+ t: klookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
0 b; g$ n3 {# b+ [+ l  c4 Nfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

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

* q& K  W. b. q9 V. w2 C这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
$ b3 ?$ [8 C: D) @- |
5 l0 [8 E9 |4 f2 J  HappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

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

CharSequence接口

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

Regex情景范例

: J) Y7 {0 @% e: }以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

& x: F' [6 L" y简单的单词替换

/*
; ?' }* q$ [! K5 Y5 ?* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
0 t5 G; g# Y3 F5 U/ E5 y/ g*/
. w5 G$ s; ]! ?import java.util.regex.*;
, W* M, K( P, q( u  ]
) D6 v7 [5 D- V  G, s; Fpublic class Replacement {
public static void main(String[] args)
       throws Exception {
$ }) b: g; F2 m/ e+ |7 C) U* n: D// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
) J" t3 H* [6 t2 {1 J% U' ^7 fMatcher m = p.matcher("one cat," +
; Z0 X' v) c% |! O3 q1 \     " two cats in the yard");
StringBuffer sb = new StringBuffer();
6 \4 |# `6 d4 [( ]) v1 s* lboolean result = m.find();
// Loop through and create a new String
// with the replacements
% W3 E4 z  N1 `/ Z' t0 wwhile(result) {
1 X6 z: y. F( i' X& Cm.appendReplacement(sb, "dog");
result = m.find();
1 b( F& ~0 k2 {}
) ]) p  a+ I) P- L4 H// Add the last segment of input to
// the new String
& I8 ]% B3 ~1 d8 n7 z1 Y. ?! ym.appendTail(sb);
7 {$ L- d' l+ g/ B$ ?System.out.println(sb.toString());
6 j. q& Q8 o8 H& c0 q0 J8 Y" K}
}
9 \) V# d) m8 H" z( |
电子邮件确认
8 Q" k2 H% n- R* r7 x3 ~' v
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

4 k( {" ~2 i0 G: w) Z/*
* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
$ I) Y( |5 \2 \) mpublic static void main(String[] args)
( \" }8 E: v" [% y2 M  e6 U. J           throws Exception {
           
, @  `+ ~/ B3 h5 R$ WString input = "@sun.com";
6 w. e( f  ~/ m$ T8 ^, N& v# s//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
5 l% z8 `& _- o  M6 ], z2 D' oif (m.find())
* }* C# B% }0 r3 ISystem.err.println("Email addresses don't start" +
7 k0 n( c  Z2 v) H# V5 R; r         " with dots or @ signs.");
! Y2 _' b' I( r0 {. P//Checks for email addresses that start with
. d8 C% p; m, M+ g( V* W+ a7 \//www. and prints a message if it does.
. e( O# S# ]& [p = Pattern.compile("^www\\.");
0 B$ b1 ?* _9 t/ u% [1 H; G7 ~m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
& f% i/ l1 q1 U& Y, W}
9 _) Z4 u1 r- d. a+ Rp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
8 L2 J' _3 D  G* U2 G5 em = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
, P0 m; W, I# ~4 B, U1 adeletedIllegalChars = true;
7 e5 r; P& [  G+ \" q1 Q& x. Vm.appendReplacement(sb, "");
+ J6 e  r0 _4 d' Nresult = m.find();
}

+ x3 N& P9 T" r& U* P- _! M: N3 `// Add the last segment of input to the new String
m.appendTail(sb);

input = sb.toString();

0 A# [& Q! L4 F2 {& U# d* `if (deletedIllegalChars) {
- e: y7 z" P. F, nSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
2 a" q4 ~. D+ i  ^6 Q7 |, c- j/ _}
}
) b% y% m' a% ^7 ~8 @+ L' ~( w
. d' C$ q' [( X5 r7 c从文件中删除控制字符

& d) r; V8 K/ V& Y+ ]/* This class removes control characters from a named
9 w( x" F) k& z( q& n8 e* file.
*/
: }  R0 \( T0 C; ~- Limport java.util.regex.*;
, r1 r# T1 S0 b% {" `+ V# U+ yimport java.io.*;

- t  {. @  S0 l- f$ c3 D6 Spublic class Control {
: a3 B9 t$ a; l4 npublic static void main(String[] args)
6 ^9 {* W1 J$ v  d5 F2 x( f! W           throws Exception {
           
$ Y* N; x9 {. O8 |; H//Create a file object with the file name
! U& }& D9 H9 t" T' _5 }//in the argument:
+ N  s% N; h, _7 p3 \. hFile fin = new File("fileName1");
2 b* X8 Y8 j5 }  P& @4 q7 NFile fout = new File("fileName2");
; O* ?7 M0 k, o  E% k* V# Z5 j//Open and input and output stream
FileInputStream fis =
  b- {8 \' ]3 i9 v/ y3 i- H       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
1 ^  U/ d0 E9 a, W$ X
7 J$ r& d" @9 F% ZBufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
( _$ ]" b6 d% b  L7 _% ~: g& SBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

) q$ S: W+ B) _// The pattern matches control characters
0 q! X5 R6 l. a) J/ q* P2 OPattern p = Pattern.compile("{cntrl}");
& j7 U; ~  Y* i. a, CMatcher m = p.matcher("");
String aLine = null;
4 l& T, r  |1 E- `' {- s; U/ Mwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
" R# Z* t! p; c! Q/ r+ ]//string.
( A+ B8 J9 O  V6 H3 O$ |String result = m.replaceAll("");
/ ]) K3 X" P4 m- `1 L7 uout.write(result);
8 |5 {! Q/ A  r) }& }) ~out.newLine();
8 M: s' S) @9 ?$ w. j( y( a5 y}
in.close();
out.close();
}
5 r! H6 |/ V9 `1 p}
' A1 ~( w- ]( I% f! `
2 N8 c5 C3 k  S文件查找
/ W. |: {7 D  X& O  Y
/*
! E/ ^! _) e: j* e) I9 P* Prints out the comments found in a .java file.
4 k5 ^% E( G5 m1 ~% K*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
+ W1 B" ?* t& n7 t  g$ m8 ?! e8 m
0 u: z2 G  _) k9 n  ]* z/ ipublic class CharBufferExample {
) r" }, h- @  m# kpublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
; |2 Z% X8 U: q$ ?/ @Pattern.compile("//.*$", Pattern.MULTILINE);

: X0 [( Z* X" j$ T: q5 `2 A// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
5 [* i. n6 N. U9 F3 v; p- uFileChannel fc = fis.getChannel();

( Q+ ?. |7 ~6 {( r// Get a CharBuffer from the source file
" b4 i/ f! e- A, q" FByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
! P' \' G2 U7 eCharBuffer cb = cd.decode(bb);
# U; P. e6 u# X4 S. N" V/ C
) A9 A' M  }- L( Y$ m- J// Run some matches
9 i& H2 y0 e- l5 L! FMatcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
4 |5 y4 k( h- [( J$ J  }}
7 U7 K2 m4 [7 i8 [}
- ]& ~1 m$ @5 f7 y
: g. M3 v& P0 f; w结论
9 I" F: s! q5 s4 j1 w现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
$ M3 i9 s, N6 F
JDK1.4之正規表示式
written by william chen(06/19/2002)

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

# M0 ~: o$ e+ c/ u什麼是正規表示式呢(Reqular Expressions)
$ `2 q- f; `* c: g4 |2 q5 i' N
7 R5 z5 |$ g3 q5 q4 K就是針對檔案、字串，透過一種很特別的表示式來作search與replace
; r6 R, e. q$ U, E$ `
7 I. G6 E( u8 {. R2 `因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
* H% C( M$ O7 G6 W, X2 K
& p! Z/ O4 [, y* Q& l6 E所以發展出一種特殊的命令叫做正規表示式
$ g; Q6 G- }' Y, M
我們可以很簡單的用 "s/
, |( }$ j$ U  h- x因此jdk1.4提供了一組正規表示式的package供大家使用
' X- u- p. E+ o
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

$ h, r/ w! S. n( K9 f2 Z+ [1 \% ^剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

* R9 ~5 u) N' }" K5 T"." 代表任何字元
4 f: \1 ^6 {* x. G8 }6 V. Z% @8 |
# t1 Y: Y/ Z. Y+ w$ p5 W- o& e) L% a正規式 原字串 符合之字串
: L2 T2 m4 V' V; v( `. ab a
.. abc ab

7 k& r: }" V' `7 b7 U, H"+" 代表一個或以個以上的字元
6 A+ K9 g/ m" h$ {. b. [! F1 Z"*" 代表零個或是零個以上的字元
' V, Q4 A, `# G. N0 n# A
正規式 原字串 符合之字串
+ ab ab
* abc abc

) X0 t& h7 v! \$ ~"( )"群組
4 r0 T0 {  s, [& q4 j4 x& X
. C7 L- _% v/ [1 E正規式 原字串 符合之字串
(ab)* aabab abab
3 u. C8 o6 h) I9 I% E( H% d! r
; x, M% h% f5 s8 o" i- }/ N9 ]1 W字元類
& ^& {  b/ ~5 p1 ]. a
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
' J4 S; N: Z7 @[^a-d]* abe0 e0
[a-d]* abcdefgh abab
) H4 L3 K5 D+ |! s# {

8 r+ m. a5 C) u% N4 o0 M簡式

\d 等於 [0-9] 數字
- R( F2 b3 I, x% E% ~\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
6 m* C0 R* L9 W\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
" k1 [* m* ]5 `# @' ]: y\W 等於 [^a-zA-Z_0-9] 非數字與英文字

( j6 Y% L5 E# f4 ?每一行的開頭或結尾

( u( a/ B& Q, l" V- R! @^ 表示每行的開頭
: i4 z# P1 b1 k$ 表示每行的結尾

--------------------------------------------------------------------------------
0 y# [, z2 g; z( O7 ]7 w
- H/ ]) R. m7 ?& I  L4 a正規表示式 java.util.regex 相關的類別
+ E. e5 N5 J% ]# }9 F, O: O
/ V# L. G1 E  r  ^* j. ~Pattern—正規表示式的類別
Matcher—經過正規化的結果
: V; \' ~# B9 W' A! a1 f7 \8 ]PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

範例1: 將字串中所有符合"<"的字元取代成"lt;"
% y- z6 s; f( B
9 W, S: S- a+ nimport java.io.*;
% l6 c; O8 j) k0 Y4 E4 N% F6 rimport java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
) J& n, u0 _8 w2 R& S*/
public static void replace01(){
. _7 a9 {9 F" {7 U" J// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
) y( A4 S+ J8 r3 u' D! [try{
while (true) {
# r) z1 y# V  H- |4 M- OString line = br.readLine();
4 B  f5 Y" L# e4 y5 }7 m5 o. Y3 L// Null line means input is exhausted
if (line==null)
+ ?* K& r& Q9 B: E0 O: xbreak;
Matcher a = pattern.matcher(line);
' o9 e/ j9 H  i. i0 ]7 ?- |6 e, wwhile(a.find()){
9 C% n+ P0 V5 |3 [# c" T# o0 h  c# ?System.out.println("搜尋到的字元是" + a.group());
}
# h/ p7 R+ ^5 I- A) Y2 WSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
4 x% I; H/ m! V}catch(Exception ex){ex.printStackTrace();};
}

5 @, U$ f2 ]9 F, `範例2:
/ U7 M6 f3 S- A  x* L
import java.io.*;
import java.util.regex.*;
/**
9 w0 N# L5 B, z4 T/ x+ R+ t* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
  C% Q" o8 V- D6 I5 kpublic static void search01(){
// BufferedReader lets us read line-by-line
8 p; V7 t5 J2 [Reader r = new InputStreamReader( System.in );
2 }0 H/ Z  T, a6 z9 dBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
3 ^6 _( A  W1 d2 M3 Y6 xtry{
* h7 P8 h( b# q7 A8 Rwhile (true) {
$ I; w% e0 q+ B; v: SString line = br.readLine();
8 o# ]- T  M; c6 o& AString words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
& z& H5 c  X1 Q) p  [/ ], Z  Z1 S8 cbreak;
// -1 means we haven't found a word yet
; |/ X7 h# J# t# S) s) j9 w! y1 Gint longest=-1;
int longestLength=0;
* {- s" O$ K* W3 ?% @2 J" Bfor (int i=0; iSystem.out.println("分段:" + words );
, [- l5 ]6 A' |9 jif (words.length() > longestLength) {
longest = i;
7 o9 s) n; W4 Q8 T' c$ P& `! UlongestLength = words.length();
9 M  A0 Y" C8 r5 k* A3 D7 _}
}
System.out.println( "長度最長為:" + words[longest] );
}
2 W/ Z7 H7 X( @9 j; h}catch(Exception ex){ex.printStackTrace();};
}
- E1 K1 k9 L/ F% b0 O
+ `6 R6 k( w- a( P--------------------------------------------------------------------------------
1 e; v7 z( H' i/ d, ~
其他的正規語法

/^\s* # 忽略每行開始的空白字元
9 Z. n8 M" B; z/ t" a(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水