关于正则表达式---ZT

Longe

第一部分：
, Y0 y. W1 g4 ]* `/ x0 i" C3 T-----------------
& C# W+ N5 y8 c4 N: P6 h正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
# u/ h5 W0 \# }8 }/ `
5 U0 f: [$ }" y- q0 `支持多种平台
+ }- a& |0 h+ B% q
" w8 f. ?, }) e* u8 i8 Y
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
/ O; `# M6 b  f9 t; q+ x
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
: Z! f& _7 ^: U  G0 {* m2 h7 T1 C% ^. x
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
1 B1 O1 a  e' W3 u. l. o* c
. w& y3 x0 K% d6 V# A比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
( S6 x+ V# x$ T1 a: O, b# ^8 {! r
0 f+ y. F$ \. P正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
& ?: t8 i2 G0 B2 T, v
第二部分：
----------------------
8 h6 C$ L" N7 x% t2 f5 `字符匹配

: n' X: c; X! v正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
+ y4 h2 b, m5 G
每一个表达式都包含需要查找的指令，如表A所示。

( O, d) ]9 P! I: g, t; h0 UTable A: Character-matching regular expressions
0 }0 f% t# r- E6 L# w. l( B格式说明：
---------------
' ?% s, v4 y$ T) m操作：
1 C7 ], g% {( V3 E6 S解释：
例子：
% ]0 J  W; c6 |" ~结果：
----------------
.
& f' W4 ~. I2 s. h# _: N$ }Match any one character
1 m  t, @# a0 S2 p! q- d0 dgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
" }( U8 B* B( M- S-----------------
[ ]
# D3 r2 e7 N' P8 y. }2 M0 }4 c' E% A7 kMatch any one character listed between the brackets
grep [cng]ord sample.txt
4 w9 H" w% f. J6 q- GWill match only “cord”, “nord”, and “gord”
---------------------
+ p4 u# Q7 i  Z2 g9 z[^ ]
Match any one character not listed between the brackets

  [+ \% f% D5 z" Egrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

! P, B0 R6 ~! y7 E+ }5 V* ]grep [a-zA-Z]ord sample.txt
: E) J3 w) X/ S( z/ c9 E! FWill match “aord”, “bord”, “Aord”, “Bord”, etc.
# L2 E/ `, G+ ]( q! t
, V+ a7 t. J, c1 @grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
2 v6 E' z' C: O/ s4 e7 ]7 n: I8 u; p
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
5 o; j% R% w7 N( K' V6 H
# |3 I0 C9 p0 E7 |0 @6 X( s" [Table B: Regular expression repetition operators
# U2 M$ A0 P, y) E格式说明：
---------------
7 g4 s' F3 g8 o$ a1 e操作：
解释：
$ f" r$ N1 ]# \4 }例子：
  q- F3 Z$ f' {, r. u结果：
; c6 b4 d9 s1 A( h  E----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
' T+ w4 E. S2 Y6 i& s' ?- R" K# ?*
Match declared element multiple times, if it exists
, k+ S* S0 U* ]: g5 Megrep “n.*rd” sample.txt
& @# M% J+ L8 {+ y4 M; l) ^  c7 T1 RWill match “nerd”, “nrd”, “neard”, etc.
6 S- d6 @4 Z, v- b-------------------
5 W, q9 U# I: G2 F2 w& [4 f/ K& l2 \+
6 Z. G2 L: r; m" T' @& T  w$ B  T0 VMatch declared element one or more times
egrep “[n]+erd” sample.txt
% Y- }" C: Y! U  r" s+ A5 aWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
Match declared element exactly n times
7 s" I8 L1 l( R9 U4 T1 F; n' H: |egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
1 o, r; Q6 i" v# V9 _6 `+ E  nMatch declared element at least n times
  v. `% Q7 a8 Z  _! E" negrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
* J: I( s: F$ ?' E{n,N}
9 u4 w9 ~& i! D" k6 fMatch 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”
; |! G# g! v, v1 {1 Z9 Q
3 a1 [9 r! Y5 A& ^4 f$ W4 q第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

9 i: c+ n2 r5 m% ^; t' ks/pattern_to_match/pattern_to_substitute/
& f5 o1 Q) F1 S4 W
  G. |7 o$ ^4 C, _5 o
Table C: Regular expression anchors
" Z2 d9 P& o' e) p: z; A-------------
操作
2 r" v0 l5 `" R, u: W. B0 m0 Q) N解释
1 e$ x" Z) y. e例子
% i( G6 Z" i! B% w0 L5 p7 l结果
: J  v$ h, K  z! i) W$ X8 f; t---------------
^
Match at the beginning of a line
6 a) }; `6 r4 Q. Y2 }/ T  U7 ~s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
$
Match at the end of a line
' b! K9 e) s9 H4 gs/$/ blah/
: E( ^0 S& N/ {* Q+ e; v+ N4 u5 C8 vInserts “ blah” at the end of the line
5 j; x# c2 t4 [---------------
" J6 Z3 R4 \# [7 R1 f2 a\<
Match at the beginning of a word
' q$ G1 P! _) ]# Y) M5 Rs/\Inserts “blah” at the beginning of the word
& L) M" A( y: G, A+ u
egrep “\Matches “blahfield”, etc.
5 [# k' X; w* F+ a2 f& i* l------------------
\>
4 m1 o0 g0 v  G" x0 NMatch at the end of a word
, {' |! F9 _' `' Q" ]s/\>/blah/
9 N& c' P1 z" jInserts “blah” at the end of the word

0 B, J; j6 H$ t4 r+ z# Degrep “\>blah” sample.txt
: n9 k- \+ m$ T& zMatches “soupblah”, etc.
---------------
" E5 B7 h: L& l, ^1 M" Q\b
* }: a. {5 R* u9 J/ RMatch at the beginning or end of a word
* e, R1 C3 V: f$ [& eegrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
% k8 g; o' y4 O) T0 Legrep “\Bblah” sample.txt
Matches “sublahper”, etc.

! a. ]# U5 U1 L7 x3 l间隔

% o, }* i2 ^; x& hRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
- X0 z0 z# v; r$ u/ {
egrep “(n|m)erd” sample.txt
; J' b3 \: a. O. j5 v; p
* b/ x, a0 D+ B2 D3 o' a间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
3 b+ i( Y$ `8 k7 a3 }' Y0 O5 x
egrep “[nm]erd” sample.txt

3 t3 x8 w/ o% l当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
, X! ^+ }. N+ s% b9 H, s----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

: z3 `. ?" g; I^ (carat)
. (period)
  W! z2 F8 I& x% g: A& J, K[ (left bracket}
$ (dollar sign)
( (left parenthesis)
& \. s6 I3 N* n, {9 y) (right parenthesis)
| (pipe)
) u9 ?& h8 Q4 c* (asterisk)
+ (plus symbol)
4 r+ f3 U+ ^0 C? (question mark)
* y4 j* A! h9 @* [7 l{ (left curly bracket, or left brace)
' e" @1 @4 H7 }7 a5 O. t' A\ backslash
+ F2 d5 I; {" c% s! y一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
# l3 F  x1 r! W
* _4 p% i( P1 T+ R  U6 N% _+ oeregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
. C+ ~4 t% b: Y9 {7 {7 D
4 Q$ C2 W$ ~, n$ n4 q7 Z( _你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
' [4 ]: `" N8 T+ a8 f$ }$ y
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
3 \2 y- R, V- e----------------------------------------
: |- u5 _+ r) g, e8 C正则表达式和Java编程语言
-----------------------------------------
  `& H9 B& \( `% R类和方法
8 d7 K- g7 |1 E7 i
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

2 F  x: O$ @' ~4 \Pattern类

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

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
& x/ I& m( z" f. a# h$ a
; v# I  m- L2 S* c用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
5 Y  i; q/ h. D4 s5 s
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

2 k  f4 \: g( ~; b9 W9 _, w/*
6 o5 z& ~' t  _% W  k; f( O4 g  C* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
. i' r& Q, ]' v4 E' h5 m: ximport java.util.regex.*;
/ n6 |( ~0 I3 q! Q
2 i/ ?4 W1 @% M' W0 Qpublic class Splitter {
% ]5 Q+ J6 Q6 B$ Y' r8 E& u+ x3 [public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
# x, V$ q8 O3 w! {+ m# ]// Split input with the pattern
1 |9 ^; r' U7 e' }9 B3 V- h: uString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
  U- `" ]9 ?# t5 y+ ^, H0 P}
4 n* p; g) j8 `}

Matcher类
; ?* j4 T! v2 y( _- j! t
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

3 s, f) U1 V9 D7 u% c通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
; E0 V% P# S+ V+ ?( z+ z" H4 ^
. U- n" G" `; c5 ~0 Mmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
: g3 g6 h# S1 C* v# Mfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
2 B& V  ^" S$ S9 E, X4 w
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

1 g1 t$ ~, S+ \' G- I- o. fappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
) v* v9 l1 y; t/ t: Y
. M% ^  a6 z; A: B. g例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
  ^2 Y  h+ d- k- C# z$ K6 J- D: w7 l
CharSequence接口
8 H5 U5 \, ^* W" @% `% n
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

1 I( Y0 ]" r9 U7 O6 R8 ZRegex情景范例

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

简单的单词替换

/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
" P; z. o- b+ t: D2 j*/
import java.util.regex.*;
8 P0 ^% D- b# J
; a* T6 a6 T) i# c# j: ^4 A! |public class Replacement {
" S/ @! W7 P; Npublic static void main(String[] args)
, |: e! {) e$ O  D$ ?" U5 d       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
. b: t" E" o& P% x// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
) f6 q3 h8 v  X0 ?     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
2 c$ h$ y" O* y7 D9 v// Loop through and create a new String
// with the replacements
while(result) {
5 T' @9 K0 [' A( V8 Nm.appendReplacement(sb, "dog");
( o$ M. _' O( m" [result = m.find();
}
% a! V; Z9 c. ]: r2 E- d' A- X// Add the last segment of input to
( d; q2 K9 o5 @8 }3 U9 y; v// the new String
m.appendTail(sb);
System.out.println(sb.toString());
. t. ?3 c6 N4 C0 b  h) {1 l7 s}
& n, ?4 [) _9 L: h, f}
& c4 C4 o3 ^$ \  Q4 \9 M: D' n
  i) S+ e- \5 I2 J0 `电子邮件确认
4 S  b1 Y7 f7 K& h
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
% ]$ G( E& M- U( j6 F. Y
( L5 d- ^" F( R! }+ n( q# D( F% ~/*
* Checks for invalid characters
( @. ]  e! L7 f5 t* in email addresses
1 w8 f+ o3 s* P+ G*/
6 F$ b6 c! P* Y+ w% |0 ^public class EmailValidation {
public static void main(String[] args)
, l: ?4 @( \# U# c           throws Exception {
- L$ w, ~; r/ p           
+ r/ S/ w( O. b4 wString input = "@sun.com";
//Checks for email addresses starting with
  M8 S8 m0 Z/ u% F/ f( C//inappropriate symbols like dots or @ signs.
& u7 q% y" G# J, T3 f2 x& b2 ^Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
( O+ k  H# J: L8 I6 M  p4 m4 dif (m.find())
' ?( R+ Q  Y2 m5 |! |) j9 @System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
6 W8 Q, h8 g$ a$ S; k//Checks for email addresses that start with
/ e4 j+ _! }+ g6 i//www. and prints a message if it does.
" q" q3 a) q) M! N' X) tp = Pattern.compile("^www\\.");
m = p.matcher(input);
8 b# {$ ]0 z' Yif (m.find()) {
' D/ m6 [: Y! p! u& cSystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
0 ~4 H: k; [9 P2 Jp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
% P/ t: k5 I7 n  R1 qStringBuffer sb = new StringBuffer();
( X/ O$ m8 X/ J1 N2 Hboolean result = m.find();
8 y; Y! |: X! l; }$ G% J% l( Gboolean deletedIllegalChars = false;

while(result) {
% [" h- D" @1 q2 kdeletedIllegalChars = true;
9 h3 q" Z8 P7 ?& n# `5 l0 D3 ]m.appendReplacement(sb, "");
result = m.find();
- {6 I. p9 E. {1 k}
/ F+ }) J9 @5 {
8 Y$ i) \, c/ o2 U// Add the last segment of input to the new String
9 u% z8 m% N( P3 [0 w1 }8 am.appendTail(sb);
, z& S+ i' K) y" f& v! N) p
input = sb.toString();

if (deletedIllegalChars) {
- e( {4 U: C8 K" d8 wSystem.out.println("It contained incorrect characters" +
1 R# C# r2 G9 h       " , such as spaces or commas.");
}
}
. p, j9 W' b( W( a}
2 t5 H! Y3 V6 n$ P
, w; S& u' L1 R6 i; C. Q( m从文件中删除控制字符

; E& j: v6 S2 J* u* J- k) K/* This class removes control characters from a named
1 K( o( t# m9 V" `* file.
+ V4 b2 b; X3 E+ X# w+ j% k& A% l*/
  @# ]/ k! J! |1 ]2 Bimport java.util.regex.*;
1 f# {  f* {3 H0 pimport java.io.*;
+ t# w# t; |; t5 ]: E
  ^" @3 S+ H8 S9 S7 Hpublic class Control {
" v1 q8 ?+ Q" L" {; G6 Dpublic static void main(String[] args)
" L( Q& L6 O8 P; V           throws Exception {
           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
: _4 ]' F6 n' q# a* c  s) U+ hFile fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
; m- r5 l" q; ~7 _! ^. t# f       new FileInputStream(fin);
FileOutputStream fos =
3 Z9 L; r. ~7 e- D  x6 e, Z+ Q       new FileOutputStream(fout);

5 {5 Z- Z, e+ \2 ^BufferedReader in = new BufferedReader(
( a9 H$ ]$ h- T! a" t) Z     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
' Q$ q  U9 T3 W: Q  a* E     new OutputStreamWriter(fos));

// The pattern matches control characters
8 e4 Y. y. _" _0 ?$ uPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
$ i6 e' Z& i. Q, j% ~  G5 z5 Am.reset(aLine);
0 b3 n# R0 b  K1 x9 {; O7 G* ]//Replaces control characters with an empty
//string.
8 A; I; s* G2 S) R& bString result = m.replaceAll("");
out.write(result);
) z1 u( n+ D4 k6 {% Q& ~( ?out.newLine();
}
in.close();
# x# ]; W. w" U; q  X8 v9 Xout.close();
0 D" K0 C4 H  e6 M5 e6 V; ]}
  x4 F0 `) e, V& ]2 U}

文件查找
1 V/ N; `" M, u7 j2 }  l
/*
- o% e) o; A( P& w; o$ y* Prints out the comments found in a .java file.
*/
$ z/ G, ~9 M4 R& Simport java.util.regex.*;
, k/ ?  o5 R' {. M5 v4 o# u( Aimport java.io.*;
0 y( o6 W4 j9 R. Himport java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
0 ?. O1 K6 z2 h1 @0 d' ^public static void main(String[] args) throws Exception {
* f! }5 B+ o. C) a// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
- a7 e. M8 l6 XFile f = new File("Replacement.java");
3 A0 B* s( E" y+ n' }# }. yFileInputStream fis = new FileInputStream(f);
" L" g4 x( Q2 b6 \* j" AFileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
ByteBuffer bb =
& n$ x# N* z. V" F) ffc.map(FileChannel.MAP_RO, 0, (int)fc.size());
, U, p' ~6 D5 WCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
: I5 [" @" X" ^. \% f. v% [9 A
' h+ F* j  p8 J3 d' t8 Q7 i$ N% |2 a// Run some matches
% p$ z0 z7 Z* e3 j1 P' nMatcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
}
$ ^3 b) R, j$ T' U1 @; Z" o+ p* Y1 H
结论
0 ~# Q$ I3 H  @# b' ~5 V* H现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

/ u+ M3 z* T$ J) n/ HJDK1.4之正規表示式
written by william chen(06/19/2002)

5 @  b$ I; b4 q--------------------------------------------------------------------------------

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

就是針對檔案、字串，透過一種很特別的表示式來作search與replace
2 q* Y- c# h) K, F% P* P" v
2 L) i1 L  i! `/ e因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
6 M& M6 w$ n( U
' i8 [. Y8 O5 j' h# H所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
7 z4 t- g4 E2 ~1 ?因此jdk1.4提供了一組正規表示式的package供大家使用
3 W) f' m( b* D7 e# U$ x
, H) B: o- ~1 ~' r7 E! e若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
# p5 g8 l* b7 }* j  V- F
9 O) |. C4 @- K"." 代表任何字元
' `1 `. f" [4 N$ z3 I9 o
正規式 原字串 符合之字串
( g; n) J! z. E+ K2 X. ab a
.. abc ab

"+" 代表一個或以個以上的字元
3 [. W1 P, y# X2 z0 @"*" 代表零個或是零個以上的字元

3 I( l( N! d, ]! d0 P正規式 原字串 符合之字串
+ ab ab
) e6 s, E) t0 }# r, m2 g0 D8 _, s* abc abc
' }# v" C+ S: p& b" u
"( )"群組
4 j. W, E; `$ n: A
正規式 原字串 符合之字串
* r% x4 p% U, r(ab)* aabab abab

; `) T/ ^! R0 u6 a% m8 ]字元類

正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab


簡式

\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
* O- A2 [; Z( u# N  S- ^! i/ A\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

# ?& V$ z5 X5 a& H每一行的開頭或結尾
, S, B# ]8 E: E) R* z2 k, A- p
^ 表示每行的開頭
# `6 D( m0 I% c$ 表示每行的結尾

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

/ r# y* P! e( T1 I正規表示式 java.util.regex 相關的類別
. U& S' _/ j9 V1 P+ {4 }* O8 E
  V% C1 |! J( I0 ~+ C$ JPattern—正規表示式的類別
0 ]. Y/ ^5 W, I5 g- q3 ~Matcher—經過正規化的結果
: I6 W! w' L, A0 X/ Q, aPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
, C: j- F/ o! B" e8 K9 A5 T7 J
/ X' U) v. X/ x6 s範例1: 將字串中所有符合"<"的字元取代成"lt;"
# s2 [7 i( g8 {- p1 w
# @2 i, X+ t; p/ R( Aimport java.io.*;
" L2 b* h+ d' q# |2 V; Wimport java.util.regex.*;
/**
# A: H" k- @) i8 v. P& |* 將字串中所有符合"<"的字元取代成"lt;"
1 `6 p( l' i2 a5 s$ b5 b7 @*/
/ R: |: ?1 b0 ~8 x( C4 R% Y# Zpublic static void replace01(){
% o" Z6 `2 M3 v1 R2 p( |9 t: T. m// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
" a7 r# E8 n6 S: r! K; RBufferedReader br = new BufferedReader( r );
2 U" {6 k; d* R+ [7 T# T: K0 IPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
# ^- g$ b8 I+ ~+ R7 G* Etry{
& c+ S  \$ S+ Y( bwhile (true) {
String line = br.readLine();
( I6 u/ L& C4 B+ E* A// Null line means input is exhausted
% M9 n% B! W9 f0 e' R0 gif (line==null)
6 _5 w; E) v( Mbreak;
Matcher a = pattern.matcher(line);
# s0 u. C1 r+ A: {/ i+ d. y. p7 swhile(a.find()){
- K& n' A; D  _) kSystem.out.println("搜尋到的字元是" + a.group());
3 ]7 g3 R0 s$ o5 T- g}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
}

9 q+ E  e& ?  B4 T範例2:

! j+ ^3 v4 w! G1 ~3 F3 h+ d, Eimport java.io.*;
import java.util.regex.*;
6 o4 o: J  J& ~' K/**
* 類似StringTokenizer的功能
1 o" V$ R2 h+ }8 @* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
, g" i* ~( N# v* ?/ d// BufferedReader lets us read line-by-line
. q9 Y, l. S& bReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
, _' {1 l! L, L& O0 \1 x% ktry{
8 W5 V0 _5 N! m4 D$ \2 o; n5 G* a/ Gwhile (true) {
, A4 P- b3 {' q7 q7 h" eString line = br.readLine();
+ [6 R4 ^" }: h0 `$ P0 f6 EString words[] = pattern.split(line);
, @0 \4 E' C" ~% B9 @$ B' T' U// Null line means input is exhausted
$ j: G* }, f# m" @( Hif (line==null)
/ g2 e$ P% m/ F0 ybreak;
/ q% m+ L2 }# u& o// -1 means we haven't found a word yet
4 {3 G2 n+ d: Z" _6 [& X9 B* Xint longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
4 v# \; h* Q. ]. Q9 I1 b$ C0 U& p# gif (words.length() > longestLength) {
/ X5 M0 q' |5 Z$ y# ?; p8 flongest = i;
longestLength = words.length();
1 X- c7 n0 t$ j6 H  N}
" @7 T4 `  A0 D" H- Z6 t}
0 ^7 ~1 W( C/ Y1 CSystem.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
4 j4 F# X, O2 W% N}

0 W* k+ G1 H1 F--------------------------------------------------------------------------------

其他的正規語法
0 B5 i6 ^9 b8 E
/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水