关于正则表达式---ZT

Longe

第一部分：
-----------------
" f5 \, a! W) U& I2 g正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
/ }' S3 j. b% X3 y) K) f/ ~* I% S
6 j- R' D) O# f$ m& U) V* A7 I支持多种平台


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

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
/ ]' ~  ?. U- V6 L( q7 B" [
& N7 l+ O8 o! u9 \- h) y许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
; O" R/ t/ T! i9 L3 j# Q; x随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
9 j5 k/ k% D0 d0 s* }. z( b
: y) D; }# E& _" m正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
- Q6 v; {8 g. v( d1 c, E
第二部分：
3 W/ E* _" z5 [% B  v6 \----------------------
字符匹配
: l2 [  z& F7 q5 V9 ~9 l
: K4 ~6 K' j" c正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
1 y- ~  b, g4 S& u+ P0 Z
每一个表达式都包含需要查找的指令，如表A所示。
2 u/ ]% I- X" y
Table A: Character-matching regular expressions
格式说明：
---------------
: R4 S" X; e$ `. V9 T# m: S- p操作：
解释：
例子：
结果：
/ k; V2 H+ `# V' I; F1 F" e----------------
.
4 J- P+ ^/ l! b  C, I! WMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
, ^% z: O+ T0 ~( c5 m/ q& s3 b: uMatch any one character listed between the brackets
) I3 D& G3 r+ O3 Tgrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
! o1 \7 p8 x$ U[^ ]
/ t3 @' x+ H) S3 k& ^* j, }4 h  ]. XMatch any one character not listed between the brackets
8 [* K" j/ L* Q! e3 B
grep [^cn]ord sample.txt
, m: S" C6 v. y" ]Will match “lord”, “2ord”, etc. but not “cord” or “nord”
0 ?6 y& {8 I+ o- R3 s$ z
8 S; A) k% A+ n2 Jgrep [a-zA-Z]ord sample.txt
' x  e0 W0 t( y) WWill match “aord”, “bord”, “Aord”, “Bord”, etc.
9 o- i4 {% \( H' e2 }" C
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

1 z$ B) h& u! \9 X重复操作符
! e; J, F% M* l, C0 B重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
---------------
操作：
2 l$ r% [8 X% P% X8 Q6 N! \. X" m解释：
例子：
* F8 z- i! L9 O- C3 m3 E' o6 d结果：
----------------
9 K0 i+ s! c: F% y" H?
Match any character one time, if it exists
egrep “?erd” sample.txt
3 b+ \" H% u; h. N, x* k  B  `Will match “berd”, “herd”, etc. and “erd”
! {( x; E' h& R5 d, `3 {, T. ?------------------
; D7 M, p9 K) q) ?- N*
. G8 L5 ?$ D/ u8 L" C' {Match declared element multiple times, if it exists
. N4 }* F8 ^3 ^: U# W. |egrep “n.*rd” sample.txt
$ k$ M. R  ]- O, Y3 AWill match “nerd”, “nrd”, “neard”, etc.
- B* e. ^3 o2 d2 p( I/ w-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
, w7 d2 M) e/ ^, r0 e--------------------
# t1 d) s/ ]" Y{n}
5 H& K& J. X1 P7 n  w5 YMatch declared element exactly n times
* A/ Z7 w9 w3 Zegrep “[a-z]{2}erd” sample.txt
3 h; G- n8 I+ n1 a  D. BWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
4 }; F# b1 U0 c5 ^  N{n,}
! K% O7 U' a2 }5 M7 cMatch declared element at least n times
egrep “.{2,}erd” sample.txt
, @: F) ^; R( ^- BWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
4 H  N( m0 q. P1 \+ e# |# F- G{n,N}
Match declared element at least n times, but not more than N times
5 I: E1 V" z' A; y; Legrep “n[e]{1,2}rd” sample.txt
/ ^" S& _: p! CWill match “nerd” and “neerd”
" k/ o6 r2 ]  i# t2 P& P
第三部分：
% T8 a# _! g9 @& G. a----------------
锚
* q* v4 H4 T" V- O8 U/ s锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

2 H5 E. `+ e( P8 a: q7 b% m1 gs/pattern_to_match/pattern_to_substitute/


Table C: Regular expression anchors
-------------
' k  O. F# J  C6 B' @+ ?& E操作
# O' n3 F; f: b8 Z3 `7 B1 ~5 W5 A( I解释
例子
9 D$ ^3 A, D  d& U/ W结果
---------------
7 X# T, T, y+ g3 Q/ K1 q3 I^
Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
" H, `2 d9 a  V; H- c' V$ R---------------
' N! i& t. H0 m7 Y( j3 i$
; e! R7 b: u% S, QMatch at the end of a line
- h0 f1 Z, r9 [; p2 {s/$/ blah/
Inserts “ blah” at the end of the line
. J4 }- ?# L5 R# J+ e---------------
) z, r5 R* G9 Z. F* l- H\<
Match at the beginning of a word
) Q5 U, U3 Q+ b3 ~s/\Inserts “blah” at the beginning of the word
( h& M/ U9 B; U) o. a9 r2 z
# L2 F: M$ {2 Q$ H' gegrep “\Matches “blahfield”, etc.
1 L: e! D, e0 m------------------
! E3 d* X, x9 o7 X\>
6 p7 s! C. c! `/ F$ PMatch at the end of a word
! R" S8 |+ f! js/\>/blah/
Inserts “blah” at the end of the word
4 V# ]  b1 o/ V% k( G/ P
egrep “\>blah” sample.txt
2 X- V5 t% m2 T% \Matches “soupblah”, etc.
# u" [4 n3 T' n) Z3 P& S---------------
1 c9 t9 o/ }  {; K\b
9 T$ Y' V8 d: o$ _  EMatch at the beginning or end of a word
! b- @5 j/ h4 t- G; tegrep “\bblah” sample.txt
( Z; _7 j" m, D" ZMatches “blahcake” and “countblah”
: h+ n7 h- A9 [: R6 B-----------------
\B
Match in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.
5 r( P6 q$ r0 t& q; v  H. t4 n0 a
0 Z' ^& W% O2 ]/ i1 e间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
5 W6 ?) |. p; g# c
, w7 e$ D' H) j3 Hegrep “(n|m)erd” sample.txt
( x: k  n: H# G
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
1 m5 U- x& Q' A
8 S' q' }6 \% N0 a, S- jegrep “[nm]erd” sample.txt

6 E' o4 K& \, C8 |$ _% ~  _/ `, A3 P当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
% \4 U, C2 G" A% z8 r; E8 `----------------
一些保留字符
5 D5 A9 x" r4 F) CRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
( m2 i( U; z: J/ F0 @
^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
, l! W' H/ ~( R! `) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
( V- c* A$ x: k? (question mark)
{ (left curly bracket, or left brace)
) V" e, `+ |3 I  O0 g9 ~\ backslash
& E; S# J- s; v一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
& y, S* i. b' W" j- ?$ A
, A9 f7 H9 \5 O/ D  ?$ reregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

7 }% C# H7 ^: X2 C3 T你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

* w& N6 J' c" W# t+ f# d% V, N总结
, C/ ~0 A4 ~# L( }在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
" m# |5 J! h5 L5 c3 x  X0 E
+ L9 @) _4 t9 ^. |% ~. g5 C! _* U4 N另外一篇文章
----------------------------------------
' H0 S4 B3 m; `正则表达式和Java编程语言
/ e  k" o" n# O* I6 T4 l4 y-----------------------------------------
' c- Q( F- S. K0 B类和方法
, s/ X$ V4 H3 X8 ?9 ?  f9 b- P, X
- V# H% r8 D: m1 i2 g# k; p$ w9 F  ]2 {下面的类根据正则表达式指定的模式，与字符序列进行匹配。
! G# j3 X7 r6 u" w
Pattern类
1 m' Z" _( R3 n! g* T6 P
  ^$ L; B6 z) @. m! J8 U/ sPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

$ Y" U# ~: i. x6 l8 M; _/ w4 e/ }用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
9 a- u8 F% Q+ W6 R/ j9 Y; C
! l( ~% ]+ E/ K& g; `* N& I用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

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

/*
3 o8 B6 t9 I6 h" Q0 Q* 用split对以逗号和/或空格分隔的输入字符串进行切分。
) [# f% w4 z0 C( k*/
4 J$ |4 i5 z* r2 ]$ O+ Mimport java.util.regex.*;

) o3 Y) V0 X$ T: `' vpublic class Splitter {
public static void main(String[] args) throws Exception {
( R9 X0 W' L. Y/ `$ i$ n+ V) C// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
" W7 n# V0 H1 fString[] result =
9 ], A( N% u' x3 V$ F, e# h   p.split("one,two, three four , five");
3 [" k8 Z, s) o4 kfor (int i=0; iSystem.out.println(result);
}
}

Matcher类

% s) g5 X% z3 J2 O3 WMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
# x9 G. q; D& B: n
' D* k# V1 \) y% m通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
/ j) Q9 y0 |; g! ?  ZlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
0 F. u4 |6 u) Y$ L* P! C
# U" m- M0 m# f这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
7 i/ o/ D/ L6 r# Z
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

/ n' ]' r: m% s( p; f3 f例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
9 o  E" L' y* ^1 B# z! |0 @
CharSequence接口
9 T" R# L! b8 U, M1 }0 e% n( U
2 q( k1 `6 c- @CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
, b0 I  e3 Z2 V5 N0 N" U
1 p7 r  t6 G! V3 O$ [Regex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

/ _' r5 \- `( |! @- K+ v简单的单词替换

/*
7 K9 S# L; ]- n( D* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
7 q2 j5 Z( u7 B1 ~) S. t*/
import java.util.regex.*;

9 c; L' L+ M# j) I; ]0 ]public class Replacement {
public static void main(String[] args)
  Z, }: M" W/ q8 f% e' K       throws Exception {
// Create a pattern to match cat
; B1 g( ?& @$ ]. m) JPattern p = Pattern.compile("cat");
( U7 J6 y: o& r// Create a matcher with an input string
- v8 q7 a1 f" U! M! f9 OMatcher m = p.matcher("one cat," +
4 |9 _$ B. `6 h, ?' A     " two cats in the yard");
+ J7 a2 ]0 ~/ {& EStringBuffer sb = new StringBuffer();
boolean result = m.find();
! ?! F% K# [9 \9 k6 y// Loop through and create a new String
! q$ S4 f3 N) M9 H$ e// with the replacements
; K7 b# S2 Q8 k* f% x* @( u' vwhile(result) {
6 f, `9 x, e9 u/ @4 l- C& A4 ym.appendReplacement(sb, "dog");
/ i8 k$ e7 D% Y' B' Y0 qresult = m.find();
}
1 T- P4 N& q1 B$ N4 C// Add the last segment of input to
// the new String
. m" w* O- Y* Y- ?4 dm.appendTail(sb);
8 L. r! J9 S( Z6 X! iSystem.out.println(sb.toString());
+ e; |2 G$ K( j, B}
}
- H8 M+ y: c# y0 J8 W" A7 R
电子邮件确认
+ k& Y( D8 ^/ j
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
& Z1 F2 p+ L' ~7 r; k: N* Checks for invalid characters
* in email addresses
% n& f5 Q+ [- y) K1 X9 T*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
( j' I& @* r( t1 ?String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
3 g# r6 [- ~- T1 m         " with dots or @ signs.");
$ s! H" q7 L# m0 u3 J4 b//Checks for email addresses that start with
//www. and prints a message if it does.
6 n* Z, h. M9 \* S( Mp = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
, G$ R/ s$ o* e   " with \"www.\", only web pages do.");
1 {7 H2 e/ F8 P}
5 P3 d& i* X4 N, Y" zp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
% k; m( C1 N* n. ^$ I* ~boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
deletedIllegalChars = true;
" E4 n- w7 r- S. Q6 gm.appendReplacement(sb, "");
9 Q& B4 l- U; m+ N# j7 t0 nresult = m.find();
}
7 @# {! a% b( E8 @" }, @: o
  H0 Y& E3 x1 v+ E// Add the last segment of input to the new String
m.appendTail(sb);
1 [' b5 s7 X. ~7 o# z# A! ]& ?% {
: @" \# [- }3 s: R6 X4 q( ~( o- G7 ginput = sb.toString();
$ H; t! k) [! h+ j$ o2 H
3 h: A( F: y/ I( |5 Q2 R( ^0 X4 O( Qif (deletedIllegalChars) {
( S+ P& T5 r/ U, I% kSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
, i( Y7 u% r$ b! G8 M: j3 R: u3 `}
- r- b$ s, ~# `5 d}
) [4 k' }: Q) I! `* H5 N1 p( D& l, J}

1 a4 M; w# d( q; i3 g从文件中删除控制字符

/* This class removes control characters from a named
* file.
) L0 D$ X- n3 l! Y*/
import java.util.regex.*;
import java.io.*;

( c/ d+ w$ N6 [4 Ipublic class Control {
6 Y+ a) [7 k& e* u  p% z) Y2 B) C) hpublic static void main(String[] args)
! G4 `% F. g6 b$ ]           throws Exception {
3 x5 B2 L. P; c           
//Create a file object with the file name
//in the argument:
' e* K/ \: e( h4 F% ^& `% p! i- j7 s8 u  NFile fin = new File("fileName1");
File fout = new File("fileName2");
/ ?4 s9 V  X$ U3 _9 t3 T1 W  N//Open and input and output stream
0 _' B' I0 b2 ]3 s: G; GFileInputStream fis =
7 Y, \! u$ H1 u0 u) Q: U$ i       new FileInputStream(fin);
FileOutputStream fos =
8 k+ U1 k7 [- K: R  O2 r       new FileOutputStream(fout);
/ |( y$ `9 b: D1 h
5 Z$ R- L5 g  n: GBufferedReader in = new BufferedReader(
! L# N; p8 x7 x5 I     new InputStreamReader(fis));
* Z# s$ S& ^6 q% o, h0 e. yBufferedWriter out = new BufferedWriter(
( H4 N7 H* x9 T- b     new OutputStreamWriter(fos));

, K4 T; B  J8 y) w// The pattern matches control characters
; f9 u* U4 O) W& RPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
1 Q+ F) U( F0 h* k0 L8 |* @//Replaces control characters with an empty
//string.
9 s* j3 [9 i; K; F* S6 s9 T, I) s0 lString result = m.replaceAll("");
out.write(result);
out.newLine();
+ f; k, A6 e8 C}
# D. L6 g, d: Y2 j9 _3 }* G; Fin.close();
; j+ G. Z2 m, ?; Mout.close();
* S7 H, ]) b: f5 j/ r' e" j}
}

4 X5 I6 |+ O; b/ E$ o文件查找

/*
* Prints out the comments found in a .java file.
1 d, r  p' B+ G+ l/ q# M*/
) E6 ~! Y  L: r+ j: x3 c8 |3 o. @import java.util.regex.*;
import java.io.*;
import java.nio.*;
- z5 R3 x+ f7 q! \2 T% y% S4 ~& kimport java.nio.charset.*;
; B( p6 J& t: {+ m+ nimport java.nio.channels.*;

0 k% i( @' P* v" G$ q0 d8 F) Npublic class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
- V; `- a# J' j7 K2 |0 SPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

$ |# p& |$ Q4 [) B// Get a Channel for the source file
7 b& Y3 N$ {9 {1 `File f = new File("Replacement.java");
3 e" S" T0 v! l8 W+ Q% D" LFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

3 n( I9 d+ J1 Y8 |$ x; ]# J! U// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
; A, P$ Y. Y; x# m$ Q5 ^Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
- h! p. R9 w0 s. L( S. P
) |3 c/ X) Y3 g$ M% K7 h5 G// Run some matches
2 z. ~! n5 ~3 q9 B% lMatcher m = p.matcher(cb);
& B8 @: E- p* R# F6 B  T) Bwhile (m.find())
System.out.println("Found comment: "+m.group());
5 u2 C; K5 ~* j5 b6 ?}
}
6 _: x8 l! a' y9 m1 \
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

! H6 [* Z( p! }* D- {. ?JDK1.4之正規表示式
1 E! T: I0 I/ ]5 X6 S: s) zwritten by william chen(06/19/2002)
8 r: Q& o4 `! |
' s, }+ f$ @% y, g& K1 Y( N* U--------------------------------------------------------------------------------

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

6 \+ X9 A& b: @9 n7 h- J. v% x1 O+ g4 Q就是針對檔案、字串，透過一種很特別的表示式來作search與replace

& M" j  r3 r9 {6 t+ E因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
7 j/ |/ g( c3 e( h( f
& ]* I+ q: }# T所以發展出一種特殊的命令叫做正規表示式

  T8 x/ Q9 O& Q2 _我們可以很簡單的用 "s/
3 f. ^- W  y2 L因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
% p$ n+ M1 F) G& K- p
剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

"." 代表任何字元

正規式 原字串 符合之字串
. ab a
2 v! V# z" p* t4 S( j/ y, f.. abc ab

0 b  ?) M8 T, x' C' [! E) L"+" 代表一個或以個以上的字元
9 ]' _  B; O. h5 k4 o0 l( p"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
+ ab ab
7 n* u9 f3 u# @  I* abc abc
$ a2 m! v- q/ }+ B; m
2 m$ j' j: X: `9 |1 I: Q0 d"( )"群組

正規式 原字串 符合之字串
(ab)* aabab abab

字元類
. R' `$ M% w7 h$ s4 B& I1 J
* D0 R7 e: V0 B5 `正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
1 Y8 G+ L1 |6 M8 ~7 B4 j; x[a-d]* abcdefgh abab

  {3 s) ^* q3 j' r/ l9 Y
/ l' d) @% Y4 ^. _$ z, }6 Z簡式
5 r5 t' _! ?; d) d. q
# U0 v0 t" O" \: l\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] 非數字與英文字

每一行的開頭或結尾
5 {3 p3 q+ U/ x0 c, l; O
7 z: |9 }! e6 w9 x' n- h^ 表示每行的開頭
% R5 }+ ^* s9 I$ D" W$ 表示每行的結尾

--------------------------------------------------------------------------------
9 _) v+ T7 ~2 G& G
正規表示式 java.util.regex 相關的類別
' `/ V. \( R& l; D% q( f, M
Pattern—正規表示式的類別
2 d* {0 k7 _% d3 ~: l: ~! LMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

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

import java.io.*;
2 m! @; F9 c3 B4 w/ z- [" oimport java.util.regex.*;
9 J/ C& H' z8 H8 b( w3 N4 i; N/**
$ w+ l. y; \2 E1 `  W1 y# d* 將字串中所有符合"<"的字元取代成"lt;"
- s$ H- c1 S- N*/
public static void replace01(){
3 @, @# u  {' n" B+ a* S// BufferedReader lets us read line-by-line
6 n3 V8 {7 ^0 y5 yReader r = new InputStreamReader( System.in );
+ @: e2 B" [  T4 W& Z  p0 D  yBufferedReader br = new BufferedReader( r );
6 h. L  k- B: X; h8 [: L- z, @$ dPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
. j3 S2 E' W% o) e5 L$ ?& Q- uwhile (true) {
String line = br.readLine();
// Null line means input is exhausted
if (line==null)
: G6 j( _. ?' u9 f+ fbreak;
Matcher a = pattern.matcher(line);
while(a.find()){
* G* @3 L- v6 L4 SSystem.out.println("搜尋到的字元是" + a.group());
/ X5 b" g" J# Y; U}
  e* S' h: B+ q- W2 jSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
7 f# a9 @! T* Q& P7 n$ P}
% A" T4 \. }, d( Q; O}catch(Exception ex){ex.printStackTrace();};
  E3 L0 u/ d7 x6 J1 h! [}
* E9 Y2 W+ d: S1 @! J
; E, [" Y% |* q0 g範例2:
- t8 `. h* L' h, ^4 y9 h
import java.io.*;
4 o7 }$ f6 H* Iimport java.util.regex.*;
7 ?' {4 N  n. l. O8 M/**
9 }5 L+ R, p& T4 }* 類似StringTokenizer的功能
- e8 N' V, x  }% K( X* 將字串以","分隔然後比對哪個token最長
9 p8 \; a- Q  D3 t0 f. L*/
' ~8 @/ i0 x9 h* @1 i% \5 E$ vpublic static void search01(){
% N, j' j6 n* z2 v$ z// BufferedReader lets us read line-by-line
9 A* a, C3 r6 lReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
) D( w9 y. q) \# u& {8 _0 Q& PPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
3 l; ~; h. F9 KString line = br.readLine();
4 a* s5 k9 z( u9 V- m3 j% DString words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
* u5 c3 Z6 c0 hbreak;
5 \9 f5 Z3 }: I// -1 means we haven't found a word yet
6 ]& \/ a% |2 k3 z4 sint longest=-1;
: A0 B  n0 D( U6 ]* L3 s2 c9 D5 zint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
$ [( B) R7 [3 d( q0 \( blongest = i;
longestLength = words.length();
. }' T9 h$ j% A}
}
- ^. }, M* c4 `6 N9 k" d! iSystem.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
& Z) [( c% r/ o2 C}
  `' j3 f" |3 I/ b
; Z4 [$ m9 u/ w, a8 ~--------------------------------------------------------------------------------
$ T6 Q$ y$ z0 G( `7 X
  s/ V/ a8 C6 W: z, c其他的正規語法
! k: L2 M7 e) p8 [- S, k$ `8 Q
/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水