关于正则表达式---ZT

Longe

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

" V0 p$ g# f2 H" _7 O5 U" r7 }支持多种平台
# M7 t! Y$ B9 d  D
3 n' O+ Y8 w8 M# z6 \) `: J
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
! j5 l# S2 m3 M& z
$ V  l5 _7 Q) ]1 {正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
  }. ?: o: E- h9 s' F% w' [
' h8 a3 D( W6 G许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
! V1 }. Q0 A7 N随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
; u0 f! x# b- R( J. f4 t% X
正则表达式101
9 z( o4 M" y+ G7 B0 \2 b# Q很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
) N7 l+ x- P& A: C7 D
; x. K) ?' y# P第二部分：
! G, E# C* f0 f# l/ y! i----------------------
字符匹配

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

& k2 X: j8 t; b* }3 z8 f每一个表达式都包含需要查找的指令，如表A所示。

8 p# y  ~% j/ b" t/ j8 gTable A: Character-matching regular expressions
9 o; Z: V5 S. T* }# }( Y格式说明：
/ u& b9 u' R' V+ t; E. t- M2 E4 Z---------------
操作：
解释：
例子：
结果：
: f+ D/ E- v, @8 ~# ^0 x6 f: z----------------
! l- {/ y$ \% E0 I7 a3 Z.
Match any one character
grep .ord sample.txt
2 z+ x  N) ^; Y0 [" L# Y) {Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
& s+ o5 [. K5 p4 s) ^: [+ a-----------------
9 x+ z1 u6 j; h7 t[ ]
2 V8 [0 V# c/ w; D! C! @Match any one character listed between the brackets
0 C8 M( ?/ E! `( ~8 A  C$ ^( Fgrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
2 Z  ^6 R& R* R+ E---------------------
% ?9 z& s% H3 T1 B2 G5 H. ^[^ ]
Match any one character not listed between the brackets

" l* X0 |) M( A4 `grep [^cn]ord sample.txt
- t7 l8 j7 K) r1 fWill match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
' J  _2 }: k- A& w( C" s
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
$ j- C3 n( n2 v4 D1 Q% u- i
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
---------------
8 O# i' f" d# A" b# q/ T0 U" l% t操作：
9 P! X7 P) M6 ?7 K4 W. I3 O( \解释：
; x/ W/ T7 o# |4 }: Q# |4 k2 y例子：
# C9 P6 ]; p* \% C* K$ r结果：
4 P0 {% i! q+ U) G# B6 L  _$ X----------------
?
+ j# U9 l( `7 H8 D$ B3 iMatch any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
, _% W+ B& q+ h& G& i*
, n) o) {' }* \2 r$ YMatch declared element multiple times, if it exists
: k, z: p. e; o. `6 I1 J  A/ megrep “n.*rd” sample.txt
, [  k* l; z& N% v5 U. ]6 I0 bWill match “nerd”, “nrd”, “neard”, etc.
" @1 F* @( u* v3 Z$ J-------------------
$ \* }9 Z  H. ~$ |3 e8 }+
Match declared element one or more times
egrep “[n]+erd” sample.txt
) I" e7 z7 R; H4 R2 m9 N% }/ VWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
% f6 E  P4 F4 X. ~) U  {Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
* m! N3 v: x* }- y- R( eWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
0 F1 s, h' H2 ]: o( Z1 |& u6 pMatch declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
& p8 X! ~$ L6 k' f6 L{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
( W3 c0 Z4 C+ ]) z2 u! aWill match “nerd” and “neerd”

, f  _: n1 {/ |3 k9 ^第三部分：
: j7 k/ ~9 n! m----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

3 Q$ N" [& C, T; G) N$ ts/pattern_to_match/pattern_to_substitute/
& a* i- t5 n+ X+ d; j3 R1 R

) d& T; G9 q9 X- J! q5 I% eTable C: Regular expression anchors
' ]9 B) ]  ~& j6 H  O-------------
5 u7 G& D1 h1 b. s操作
5 a8 v# E+ Y0 p+ o, ]解释
例子
结果
---------------
+ \: `0 |4 p6 @: S- Z7 C^
) O$ \3 O6 {% ]9 OMatch at the beginning of a line
s/^/blah /
5 n3 F5 L; N1 W0 }) nInserts “blah “ at the beginning of the line
7 A; X% X& _8 C( |2 r) @$ d---------------
$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
! v' ~$ N& ^: w* N# s+ C8 Q+ q---------------
\<
7 @3 t1 P) C) b7 m" SMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word
/ X% u+ `! ]5 E' L/ b# t
egrep “\Matches “blahfield”, etc.
------------------
\>
9 f+ E& q2 A: Y4 ~; ?9 s  p2 V1 pMatch at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
+ H& n: C& q1 ?' c- Z
. G5 N$ P$ B  N$ J  z( h6 ^egrep “\>blah” sample.txt
  v5 M/ a# `" F, l" gMatches “soupblah”, etc.
---------------
: C- w) F* \( o5 J\b
# g" j' D6 K; I1 b' `4 sMatch at the beginning or end of a word
egrep “\bblah” sample.txt
0 T0 l+ F) D# Z, vMatches “blahcake” and “countblah”
/ o  C' W# b: ~! H2 Y7 x-----------------
  P0 K: G- |1 U\B
Match in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.
8 d& Q$ M0 }* T
* F  q: `2 k$ [/ H- ^间隔
) o4 I/ F1 m. ?7 Y" n; c
2 c2 `4 Q% r5 V0 URes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
% m+ Q/ l  u3 S6 E& t/ e2 T. A
7 b5 Z( g5 z+ O" @6 H+ }. \egrep “(n|m)erd” sample.txt
# l" ^6 r" s, [$ Y) b& I
2 F4 d8 {6 J& I2 G间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt
, Z$ L/ I  }) `3 A. y1 }8 h2 n
! t7 U/ C2 U+ K- w/ X! J当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
8 w9 I+ |2 v: z& N" c
- Z7 J& P% [) a9 Y  R1 }( i2 K: q6 ?第四部分：
----------------
! i; b$ q( g/ M* e$ \% e5 b一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
" Y- O; K3 ~5 l; C  y+ W' s  ^. y. (period)
  q: \" B+ U& K+ A$ ~: W& C[ (left bracket}
$ (dollar sign)
9 s/ H; H, b! ^( (left parenthesis)
) (right parenthesis)
9 y% O0 h" S  W  z0 N| (pipe)
0 W. r  h3 g! v6 D; P! p* (asterisk)
+ (plus symbol)
# R6 e" Q5 A8 C2 O- T? (question mark)
) n. n. m, y7 ~, O{ (left curly bracket, or left brace)
\ backslash
/ b+ q1 |& L" V* q/ |+ M. e: W一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
  O4 z+ `7 D/ O2 s# `$ j4 }% K! {
, f# M( P, U. [你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

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

另外一篇文章
- v2 i  a% G5 k) g----------------------------------------
$ F0 A* D- O% o$ S: U正则表达式和Java编程语言
$ k1 {/ J3 ~4 N* B4 X: v-----------------------------------------
1 R" `' j, ]/ Z类和方法
* c. K2 V/ V* F2 v8 G% b6 o" a4 Y
下面的类根据正则表达式指定的模式，与字符序列进行匹配。
' l) A! n; i1 x6 x* K7 X3 q  N
Pattern类

& z: F( n4 \2 t8 UPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

6 J' A' {$ K  ~* i3 h* [% U用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
# G1 f0 o& R0 t
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

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

/*
* m8 W0 r5 f3 [* x3 f0 s4 i* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;
; d. D% l: n3 ~
6 z7 }+ v6 q9 x1 opublic class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
8 |2 W" A4 C. k: G# s& m; ~# P8 sPattern p = Pattern.compile("[,\\s]+");
& P' p' a% U) E3 A// Split input with the pattern
String[] result =
% q0 |( l8 v" z) N   p.split("one,two, three four , five");
$ ~1 N( Q/ N4 @# q: _. `for (int i=0; iSystem.out.println(result);
}
& J. |. r5 @% T5 e6 H; ~8 c5 m}

8 n& W7 s( R+ f" c; g# TMatcher类

6 l5 v0 K  n6 `$ M3 P8 z2 IMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
6 O: {) }7 g0 l7 w3 K
3 B0 p& N. q: j0 p通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

8 T- |: ^; v$ }# Lmatches方法试图根据此模式，对整个输入序列进行匹配。
! G0 r# S0 n) D; f8 i. c3 VlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
$ C0 x; l7 ~9 g: h$ O7 V3 H% sfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
3 `9 h( j) _" [* \# \
3 Q$ U. G2 ]' p, Y这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
/ q: D- E; g: A# O
( {7 k1 W4 L* t) lappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
) j3 x: V2 u5 m6 ~/ q
1 S( \: ?" Q6 n2 \" rCharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
: ]) r/ o% z4 q8 c5 M& C
8 W( w  O! _" _! X1 O( o& @1 kRegex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
# h4 O7 w0 i8 v$ @) L  ?: }5 l/ W
+ ~' r5 A2 Q& ]  d1 ~) l简单的单词替换

/*
9 }/ L3 Y) ]5 u1 G( c* This code writes "One dog, two dogs in the yard."
6 I3 m  Q0 v0 `" |: j7 n9 O* to the standard-output stream:
*/
9 c& |7 ^" f  n. r8 Mimport java.util.regex.*;

6 s- s2 V  ]0 ]+ R7 t; ypublic class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
, m/ }9 b$ R) L) n' F6 qPattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
1 T8 h0 w. I/ `) i& gboolean result = m.find();
. W) p- Q3 m& y( W) Z/ r// Loop through and create a new String
4 p. ^$ K1 j2 |% v$ J1 N2 w9 y// with the replacements
( v5 Y2 y( L* B, K7 owhile(result) {
' A. j; U* d: cm.appendReplacement(sb, "dog");
) E3 o; Y8 n9 N; X9 O! `) Nresult = m.find();
3 T% x1 T- _  P. E( @" g  r) f& Y}
9 @: `' s2 j* K( X3 o// Add the last segment of input to
6 C( E. k# L: X. c// the new String
m.appendTail(sb);
System.out.println(sb.toString());
}
/ D8 Z* ]' g1 _& D! `6 t; @. B5 e$ M}

电子邮件确认
: {( O6 x  a( `! S9 g  Y6 ~
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

+ g2 b/ P( K9 ^/*
* Checks for invalid characters
( `! y: z+ T( E& i* f# y! c2 n; {* in email addresses
*/
public class EmailValidation {
1 E, F& i8 t# {9 s4 f: p3 \! d3 jpublic static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
' G: d# e2 w' q& R0 B" K; ]//Checks for email addresses starting with
% I, h9 Q! [- _! i* E$ X) V//inappropriate symbols like dots or @ signs.
9 M* m6 K' \9 z0 T+ K3 f/ LPattern p = Pattern.compile("^\\.|^\\@");
/ _+ y1 E4 T' q, o, ?Matcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
9 v7 Y& s2 ?: k& I         " with dots or @ signs.");
* O: \6 P* D" Q0 p4 C% M, _//Checks for email addresses that start with
9 _/ B  v: [5 z+ a, {/ K//www. and prints a message if it does.
) P; ~0 [6 y7 ~- [' c6 j; X1 up = Pattern.compile("^www\\.");
m = p.matcher(input);
: l6 t: S! a+ A2 Kif (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
5 X) |& G  Y, q: U2 p/ P}
; t! n/ I+ T7 g% O- Np = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
% ]1 k/ Z7 \3 S+ XStringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
  y2 q% ], x+ s% R
while(result) {
- J+ a5 i0 W( i7 ]+ a. ]; [3 CdeletedIllegalChars = true;
m.appendReplacement(sb, "");
2 U! p/ o, S! T$ d& sresult = m.find();
}
: W6 u+ i! \5 B6 D. D
% J# h9 g; v6 M// Add the last segment of input to the new String
m.appendTail(sb);
$ F6 z9 U* w$ m3 R' L
# w% p& E! A- p  S+ t: {input = sb.toString();

if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
& T1 ^) i  j  L8 _1 j, v}
9 Z: J  T: r7 P9 X+ d+ f9 Y  S8 w}

7 [- [: X! x! r  e% U9 X  u+ S- p3 \从文件中删除控制字符
' M& V: p4 i: M3 _
/* This class removes control characters from a named
) e: X( Y2 L* G; m0 |" }4 F% ^* file.
*/
import java.util.regex.*;
! m3 N; r7 [1 m1 Q# J2 D& Himport java.io.*;
0 x! Q, s  l+ h& [0 n7 g" K% O
public class Control {
public static void main(String[] args)
           throws Exception {
; u8 l4 I% X% B2 `0 n  {2 A           
- i1 m+ a* r* w* M6 a//Create a file object with the file name
//in the argument:
- b: U9 c3 g( e/ H) C* l0 Q- A' B. F$ EFile fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
9 j4 D- \9 a$ V; q' s6 ?1 Y       new FileInputStream(fin);
FileOutputStream fos =
* b$ f9 n" r. k5 `1 e7 Q8 b$ B# H       new FileOutputStream(fout);
& q) M; x$ A3 I  V
BufferedReader in = new BufferedReader(
$ ?, O' J9 \/ z     new InputStreamReader(fis));
( k  \* ]" i' wBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
' c# {# J! s9 cString aLine = null;
% P) l5 d( ?; `/ O5 _  ~6 bwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
' r% \" D7 [9 P7 K6 }" L; }/ I' ~String result = m.replaceAll("");
8 V+ [5 z1 q  u* u- W; Zout.write(result);
out.newLine();
}
* H! _# \% z2 Vin.close();
: Q0 V0 ^! ^8 W4 q8 W9 |8 g2 p2 nout.close();
}
" D( e' ?5 ?  \( N: M4 V" u: {  v1 Z}
+ q% T6 m4 N2 p$ T* S
/ k4 {$ ~7 O- Q9 T文件查找

6 z0 r+ |. W9 c) V* ?: s+ O& ?/*
* Prints out the comments found in a .java file.
*/
# S# m8 a: ]0 I; v" Ximport java.util.regex.*;
import java.io.*;
/ n# v) u5 v5 ~import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
( x4 b& W; ]0 M! {) s  ]
public class CharBufferExample {
public static void main(String[] args) throws Exception {
0 G; Y( Q) s8 B// Create a pattern to match comments
Pattern p =
% S, z8 g& R% u3 Q; M+ \1 jPattern.compile("//.*$", Pattern.MULTILINE);
4 V# W3 d+ P8 o
" E: X2 T/ S9 p  Z  D// Get a Channel for the source file
5 l1 S8 e* m7 G# Z; ~7 `File f = new File("Replacement.java");
% q% X8 s8 _, G( R! nFileInputStream fis = new FileInputStream(f);
7 T, I/ O* R+ D: I: gFileChannel fc = fis.getChannel();

) s1 ^( z& }- o, [) M6 ]// Get a CharBuffer from the source file
. Z+ ^; Q, t  q: K0 E2 TByteBuffer bb =
: L4 I- Z3 W* T3 q# c8 g' Lfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
; Z  D0 w: }' ICharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
) ^, d7 ]+ N3 w$ j& tMatcher m = p.matcher(cb);
9 y: k7 m& X2 A, }while (m.find())
System.out.println("Found comment: "+m.group());
- p/ Y2 Q# e, U2 N# ~; b}
. ~5 g5 f( H1 a' k% ?}

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

9 T. X& _) L8 X$ g+ q! f* \4 EJDK1.4之正規表示式
written by william chen(06/19/2002)

9 F/ \% E+ S  }" o--------------------------------------------------------------------------------
# p2 d- J8 A1 o) Q$ h  U' ~" e9 ~: J
什麼是正規表示式呢(Reqular Expressions)
  F  n! C3 w& c" [
9 \" H  k! ~6 D; J0 V就是針對檔案、字串，透過一種很特別的表示式來作search與replace

5 Y- I' F9 b& R因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式
2 {: C! E3 K# n) H, |" L6 ?
! j7 T) |0 m8 l' b# m我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
3 N8 m: ~; F$ i
6 `2 R1 z1 Z; X, d0 E若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
+ v6 d" G" `! f適用於j2sdk1.4的正規語法
, S0 J% l8 F( o- i( I
3 o$ H" K5 D5 c7 I"." 代表任何字元

" t* ~5 |4 H0 V) c7 f( ~3 }, h/ c正規式 原字串 符合之字串
. ab a
, m1 I) p  j* r8 @' D5 {.. abc ab
! r. p/ f( Y- C9 h! H# R: y* W
+ S/ q; w( B* a9 w* I"+" 代表一個或以個以上的字元
* `' r! N4 \% K# m) X7 k"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
( }8 u) {% E2 o5 U+ ab ab
* abc abc

: e* `* U! I- i" A"( )"群組

正規式 原字串 符合之字串
, l' m6 K. e1 V; n(ab)* aabab abab
  b' ?0 i7 B, k* p
字元類
2 q- s3 O1 T! ^3 c) o0 H
) X! N4 ~6 c+ j( E% g0 {9 k  a5 C& y正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
4 r" Q3 g7 g; w& S[a-d]* abcdefgh abab
% r0 t% t/ l) m
2 q/ p( x* D) N: ^! S9 ~% f
! |' K' [* @% B( x# \) o, r: r- ^" F簡式
9 s; K: u2 o: ~5 }. v0 t( n6 a, j
! p; V- i6 F( n* E; l\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
+ S& }9 R. h* ^9 b" E\s 等於 [ \t\n\x0B\f\r] 空白字元
; h* }* u$ i& S% R( X% W# ^* Y" o" L\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
$ o+ V# a8 B! e4 O. S. }  a\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

2 i: X& R% I0 M% L) m^ 表示每行的開頭
$ 表示每行的結尾
* h  |7 l0 u5 X8 u
--------------------------------------------------------------------------------
& J2 x4 E* ~5 J2 S! l% {4 f1 B
+ W: d0 [. i& P8 V2 L  W) c( L正規表示式 java.util.regex 相關的類別
% B9 X5 X. I! b  N% p  k
Pattern—正規表示式的類別
2 l. r! n) r* U4 ~: Y7 cMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

* O6 x" Z  V& H2 K0 N6 U範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
$ _' I0 @9 ~# C0 v5 Kimport java.util.regex.*;
8 a5 }6 ]5 {' D) L2 v, I/**
7 [: I& ~0 y0 [  V6 c* 將字串中所有符合"<"的字元取代成"lt;"
8 H# r/ X5 D9 I( g* ]# }6 {*/
public static void replace01(){
! F, M+ w4 {0 l// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
9 S% m9 s, `! n- x. ^4 Atry{
  u3 ~( W4 T) owhile (true) {
String line = br.readLine();
// Null line means input is exhausted
8 `' U* R1 A7 dif (line==null)
5 ?, h. c( E4 }! Pbreak;
Matcher a = pattern.matcher(line);
6 T, t: l- l, t7 s' Gwhile(a.find()){
, b7 Y0 C+ ?. V, ?System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
/ V$ F& m7 t7 d5 d* ?1 z# |}
}catch(Exception ex){ex.printStackTrace();};
! H' {* J7 G7 p: j' U' S$ H}
9 |4 g! A- j' P/ R4 A1 g6 H4 |# |
5 J0 B: o- _/ U, g1 Z: X範例2:

) B2 O8 A; L% n3 O$ }( |import java.io.*;
/ c- v' d3 ^- u" s+ Zimport java.util.regex.*;
/**
6 j; j% Y/ p$ |, ~# C3 G9 A* 類似StringTokenizer的功能
$ X4 v- g1 m1 A5 h/ A* 將字串以","分隔然後比對哪個token最長
*/
- z. u7 P6 F3 ~3 p% w; }public static void search01(){
, ^, l. H2 |3 m: r, B. ?: M// BufferedReader lets us read line-by-line
0 x- t; L! I  M8 nReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
1 w8 W1 p) l4 ZPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
% m9 R% l( [8 {8 Y* W1 W9 D$ Vtry{
while (true) {
8 A/ E: G5 @9 O& l" o* }9 P! oString line = br.readLine();
1 K4 o' f8 q; G7 P5 L# _2 tString words[] = pattern.split(line);
# g$ j7 q' S: d3 S9 N// Null line means input is exhausted
" r2 u5 V* a# i  s8 gif (line==null)
break;
// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
% y; E7 ?" L; a4 g* K2 }if (words.length() > longestLength) {
longest = i;
longestLength = words.length();
}
3 F( W7 Q3 E0 J/ q, K}
System.out.println( "長度最長為:" + words[longest] );
}
) q: A6 f7 n8 V3 D& v7 t% [, C* S' S0 {}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------
1 p' `( W, b7 R+ D
其他的正規語法
" |4 F' I. p2 m3 b& V
. g( {3 ]" x2 [! B) @3 @/^\s* # 忽略每行開始的空白字元
9 y% Y! \' ~( h: c, U* ?2 M4 r, @(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水