关于正则表达式---ZT

Longe

第一部分：
# \2 J. u7 Y7 F4 }- T-----------------
" @; C6 }5 u7 U9 V) [. r* w& C正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。

支持多种平台


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

' \- p! f) W  W2 C, S0 @正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
9 T8 h1 X; J' r- T. C, U2 l
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

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

5 R4 a* w! p6 ?, a! u! s3 J8 O正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
! U4 O: a  y2 L5 H, j" Q' u  M
第二部分：
7 J( Q% G5 X' Z5 y1 P----------------------
字符匹配

0 g+ G/ ~; `! \: S' |: Y& N+ C+ n8 ?正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
( \) n. B+ s/ H7 f: ^0 P- L+ k
每一个表达式都包含需要查找的指令，如表A所示。
% N( {  z* [6 ~" y
Table A: Character-matching regular expressions
格式说明：
---------------
+ G: O1 r- X- \: w( P操作：
- C6 d( r2 [! h解释：
例子：
3 m4 h5 U1 h$ e; g! x/ h结果：
----------------
& C% }( z% b2 E0 A9 C1 w. L.
; \3 s) ]! l$ KMatch any one character
" ~! Z; H& Y7 x; G; l3 r6 }+ Pgrep .ord sample.txt
' U; ^( G( E1 w( g! F$ gWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
# y1 I; x6 o* G; ?Match any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
[^ ]
  D: V  ^) f" d4 p; N4 D$ AMatch any one character not listed between the brackets
) P/ F0 ~; @/ u3 W# h/ v( ^; f
4 w5 A+ y. l( G; qgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
& l$ g0 `& [5 s$ a! M8 U! n
  Y0 w- }: ^) G0 \* lgrep [a-zA-Z]ord sample.txt
  ^/ l1 `9 Q3 r5 a% aWill match “aord”, “bord”, “Aord”, “Bord”, etc.

% Q' t6 e+ d5 r) |grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

4 c; Q- k, Q  s: i7 U) Z) ^+ U重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
9 D, K2 E) G& B7 c
! m0 p+ y4 O0 Y0 W5 ~4 S* _6 aTable B: Regular expression repetition operators
0 I3 f  Q6 j' D% \: J! P格式说明：
, v: Z1 u6 J5 S8 u# W* w---------------
% p& A0 T) o: B, W8 J6 \% V+ U操作：
" e2 @2 T0 f: m+ q# F) @1 \3 A解释：
1 P  ]" n7 P8 e% e( f7 \例子：
3 {6 _9 O! s& m结果：
----------------
0 s9 ], E: ?( \8 J) {?
Match any character one time, if it exists
/ e! w/ i- D1 K, z. Megrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
3 z2 [2 W; H$ i! z! i# `1 _8 h------------------
- N3 e/ A; d% _. Q4 U. F; s0 i4 B& V% y*
Match declared element multiple times, if it exists
- _4 A1 k! e0 w3 }. p  }+ |egrep “n.*rd” sample.txt
9 e, }9 N8 N2 \/ I" U/ UWill match “nerd”, “nrd”, “neard”, etc.
2 d& I5 t# {2 b! f. v-------------------
' _$ y; g. o# q$ d9 y. f5 b+
8 F" B* r/ I! G+ w8 K1 z2 i* HMatch declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
+ I$ U; s9 Z+ j3 a--------------------
% y2 ~$ b' S- _1 X0 ^{n}
1 X  e0 @2 p" L4 _. z/ cMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
1 K2 G7 k4 s, W+ |/ Q' ]Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
2 V' p  u, l7 i' SMatch declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
; R/ e! k) w2 E{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
8 i$ P. Y6 u* g3 YWill match “nerd” and “neerd”
9 p( U' q9 i+ c+ W) r3 @* |
第三部分：
----------------
# u% d) P9 }8 H% \) a( l* U, J锚
# n2 m. l7 O# {: w5 d锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
2 X: `; k: \3 R4 z" v
s/pattern_to_match/pattern_to_substitute/
# y7 `+ o1 }3 r% c8 s8 o

Table C: Regular expression anchors
5 h* v; S- C6 }1 o-------------
! l' e& \/ d  l$ s7 N, i+ A操作
解释
例子
" t7 q- Y) U6 N结果
9 j+ e5 F2 F  I  Y# t9 [' |---------------
' n3 k) K) `$ R( x! Q: d^
Match at the beginning of a line
s/^/blah /
! v3 y/ \: y5 h! DInserts “blah “ at the beginning of the line
1 c, \6 q' a3 f7 P  Z7 a& H/ l3 [---------------
# i0 `. n2 P( ^$ j) S$ @" t$
Match at the end of a line
2 g: ~; _% Y. ]2 vs/$/ blah/
: u8 Y) e9 I9 a$ aInserts “ blah” at the end of the line
/ m& [3 Q4 v2 ~9 f# Y5 R---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
  }, q* @7 |* w- Z7 {& F# Q" S" }
egrep “\Matches “blahfield”, etc.
3 ]- ^6 {& k0 p( S( P! a" v------------------
" ?( y1 N% h7 f0 \0 M) u\>
& y) ?, G7 T. oMatch at the end of a word
: [! p+ d. _2 Ys/\>/blah/
# v1 X# s  }7 ^2 G8 |Inserts “blah” at the end of the word
2 l9 A" ]3 |3 @) }0 j
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
+ ^# J4 F/ Z* Q9 H9 Z6 ]) R---------------
0 u2 f" \' t7 m1 O6 c# `\b
Match at the beginning or end of a word
: @" [( ~# f. f! s, l; segrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
- Z0 A" l# g/ M4 p\B
: C/ {/ m4 G3 y& EMatch in the middle of a word
egrep “\Bblah” sample.txt
* F- i* k) M. F) E( r/ {Matches “sublahper”, etc.
6 [5 q: G# ~  O/ ?; O/ G1 t
间隔
! W8 ^* N% r- e0 A! i$ I' ?
Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
$ m8 n9 B' V$ L+ l
' v# A) E2 }, a1 X, A, \egrep “(n|m)erd” sample.txt

9 q4 R$ }* t& {* a4 @间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
8 }1 s1 a% b3 G9 u0 J" X( S! I
egrep “[nm]erd” sample.txt
/ v, k9 u/ @& Z2 t, T* G
( }5 E* F8 a4 N+ g6 c当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
# e4 C( W  W/ R. s' \9 a9 x
第四部分：
----------------
! F+ \$ E: x$ V4 b2 v一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
( ~+ ]# V; a# q& l, C, m
^ (carat)
. (period)
[ (left bracket}
$ {7 u& \* D5 f3 t+ d$ (dollar sign)
. D4 k% Z% {( ^4 \+ E5 X  Q( (left parenthesis)
0 d& ~2 D: p# ^" W0 j! O; c) (right parenthesis)
$ a! W: ]0 z- d| (pipe)
* (asterisk)
+ (plus symbol)
- d# ^- h4 R" u; n: {3 O7 w? (question mark)
{ (left curly bracket, or left brace)
\ backslash
- W  _1 t6 ^  j  ^4 u; y$ J一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

  x1 A' J8 m, }1 [& ^& m- Oeregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
' z; |4 q7 i- @; r
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
" K8 N; E9 `3 O, B  ?, I% m, q3 ^
3 ?- V- T* j6 b) u' V7 w总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
$ D) L2 }! e) K; `, W
另外一篇文章
/ _% N' m8 H3 b) q2 Z5 {3 n----------------------------------------
" T: ?4 E9 p" P8 ~7 |2 `正则表达式和Java编程语言
-----------------------------------------
1 G% A7 q. t) ^( v. @3 a7 l! m, Y9 F类和方法

; G4 o- q+ }; J; O0 a下面的类根据正则表达式指定的模式，与字符序列进行匹配。

8 a8 ~) k- H8 E$ S" B- }% UPattern类

3 ^. m4 h, M! P8 H2 V* ZPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

$ y2 r2 x$ E/ Y1 s+ P用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
0 G: b5 @: X. `. t" L
, ^+ I) j, d& gsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
8 n' g: E: R; M
" {2 `  c( G8 k) b, Q. N/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;
) N5 p) u) K- r( v% J  d
9 F5 }$ z. ^# n0 \: D( r( lpublic class Splitter {
. j9 ^6 r2 Z  g# hpublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
* j& M, K) n' P: S! J// Split input with the pattern
* L7 j) w' C1 OString[] result =
$ |( g. {. U  g$ @, a- Y/ O   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
4 I, k/ y: [: C3 q# \% Z}
}
) ~* i' a1 Q) R8 g
7 l1 X" X# j  ]. [* x# l+ EMatcher类
7 c7 [7 @% p% ^$ B- S! C8 `
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

: Z2 B0 h/ N  y5 Y8 A" M! S( Y' d通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
6 f; J2 C  {+ {9 }7 p: {
8 \" y4 W* Y1 a+ `$ Pmatches方法试图根据此模式，对整个输入序列进行匹配。
3 D% n$ X$ X" @* q3 m1 t4 i' U3 ~8 _! mlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
7 v/ L. Q: U& a+ d& Y
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
: V( X7 L( z6 X3 m" z  E, {7 D
5 j4 h; w1 U8 ]这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
. O" y6 t" |, p9 b* ~
7 X& ^% [$ D8 t' s8 i3 Z$ GappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
% Z0 c( V" [5 e% @! R3 I" b
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口

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

Regex情景范例
: ~+ S/ Z6 \! }. `" B
  \' F: ]  U1 u, C以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
" E$ N* p  T2 k1 R$ e- m8 o
简单的单词替换
6 H4 ^! b( @/ n' x. E( ~+ O
3 b* p) A, i- Y9 [! s/*
8 e3 n* U+ w3 _; z* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
! y8 r4 A+ {5 L% |0 @- z$ A; E& _*/
import java.util.regex.*;

; Y# l1 d- N: J/ l+ Z( `public class Replacement {
6 z; ]0 }# v, u( kpublic static void main(String[] args)
       throws Exception {
3 _' p7 h" z: m// Create a pattern to match cat
- X  W/ @# r4 Y0 KPattern p = Pattern.compile("cat");
4 m; k, D  p% c% U$ s1 |' y// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
/ D5 Z& {# x$ o- k0 m' A, Q/ L, Bboolean result = m.find();
3 E- @6 B2 `5 Q6 g// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
9 t* S$ ~) W, [$ G) f+ H}
// Add the last segment of input to
// the new String
1 t$ ?; g" _5 J: _  g5 t+ {  V5 Om.appendTail(sb);
1 z! Q- L; Y) ]$ d; ^System.out.println(sb.toString());
, C3 ?+ k: Q0 F7 ]/ B4 U}
+ L0 t" O' {2 t/ W# ^9 ?}

电子邮件确认
# @/ F2 A  k: S1 q6 `2 {9 o$ u
" h$ {/ t( {6 x" H( B+ _* b以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
* Checks for invalid characters
% [# `9 j/ R/ t* m* in email addresses
*/
public class EmailValidation {
( J% K- w; S; f) |4 ?, Epublic static void main(String[] args)
           throws Exception {
+ W( p2 s7 k; U           
String input = "@sun.com";
5 K" z  ]3 D- t  l: ?( k* P* B% e" o% m% y//Checks for email addresses starting with
  U1 H; C5 C7 [1 G5 `# k# Z//inappropriate symbols like dots or @ signs.
" D+ O3 V7 c+ Q; @8 D. h1 dPattern p = Pattern.compile("^\\.|^\\@");
* V" W9 S4 s& {& _  t& G) ^Matcher m = p.matcher(input);
( L1 `1 X+ C1 c6 d7 y: o5 G& rif (m.find())
- @2 q, M9 d* P$ wSystem.err.println("Email addresses don't start" +
         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
( \5 t) n& D$ m2 x, Bif (m.find()) {
System.out.println("Email addresses don't start" +
' }9 }/ i: R  x1 N( Z& J6 k   " with \"www.\", only web pages do.");
3 H- ^( h2 O; B' A}
% s+ X- `; ~3 `: s5 i4 t% I" Zp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
) U# X, d1 U9 P: v* _
: C# a& a1 J6 g$ Ywhile(result) {
2 h2 y: }5 ~; }: m5 YdeletedIllegalChars = true;
- ], L3 i3 ~6 ]. h3 A3 R& qm.appendReplacement(sb, "");
result = m.find();
}

1 P/ Z* g# _0 n! V1 l// Add the last segment of input to the new String
m.appendTail(sb);

4 @" {) C# R0 q6 Binput = sb.toString();

if (deletedIllegalChars) {
5 p5 ^; j0 w8 PSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
) R1 c/ }7 Z2 y8 B* \5 H! r+ o8 o}
; X: M7 E  |. K  j9 t}
}
" [1 Q! d" _& i% X; M/ x
4 j3 O- `& b$ A* g从文件中删除控制字符

% p) w' l$ d: p) [7 Z) h- x, [/* This class removes control characters from a named
* file.
6 {( _- x) Y2 [" C2 R4 m( t* o*/
' o) Z8 l) ?! J" [9 g( Bimport java.util.regex.*;
import java.io.*;
: `, o6 A  ~% a9 U2 ]3 o
public class Control {
public static void main(String[] args)
           throws Exception {
. v1 s' g  l2 G8 ?0 `           
9 w/ k7 m! w' \* d1 E# n//Create a file object with the file name
6 J( l' v: I8 M( V2 x//in the argument:
' w0 E4 o; H% C- h( A; N* ]5 YFile fin = new File("fileName1");
File fout = new File("fileName2");
2 |5 H$ O- U# E3 Q; B* S% I) S) Y//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
* h8 P. J" r6 GFileOutputStream fos =
" S# P- e  b$ U. ?1 O. y       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
* m( W: E9 @+ ?8 Y7 GMatcher m = p.matcher("");
$ x! z, j) r- n! `String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
. Y4 Q! l% l* w& T( Y//string.
String result = m.replaceAll("");
+ r! o$ z6 z" |0 V% fout.write(result);
' i" d3 f" x$ _0 d8 u! }2 I' J* kout.newLine();
+ K  i3 B" g1 D/ ~' `% [' i}
8 {, t0 f- H. c9 M' Lin.close();
4 z4 F, |2 D# n' Qout.close();
}
}
+ L3 c* V  S* Y1 j; e, X
文件查找
/ v' G* l3 ?7 J, T4 v
; Z: c9 o& K8 C1 X0 Q/*
7 z# S; o# @% X" a3 Y" f' Z* Prints out the comments found in a .java file.
*/
9 b8 g% y* n; o5 _) F; g6 A+ kimport java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
! M+ w1 e- h; w; f9 ]' N1 G7 KPattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
File f = new File("Replacement.java");
& J2 t  X6 d9 N4 P0 E6 TFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
1 L, N+ f) w" G) U/ F, b  `
// Get a CharBuffer from the source file
. M; a' D$ s" h! [: }/ sByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
& {5 {) [8 f4 N( Q4 TCharset cs = Charset.forName("8859_1");
# ?) C  y4 ~% i# CCharsetDecoder cd = cs.newDecoder();
- z' n  ]" ]( o/ xCharBuffer cb = cd.decode(bb);
2 E# C( k/ z4 h+ ~
$ z* i) n4 B9 ^* a// Run some matches
! D8 z) \# e9 o9 b# w$ nMatcher m = p.matcher(cb);
& L1 t, t6 r5 a4 k' L  Swhile (m.find())
4 V3 Y, V$ I" p6 e( Q# n6 }System.out.println("Found comment: "+m.group());
" o) v. o) E% Y$ |- J  G/ a}
! n& b" H0 E+ P0 w/ {: K}

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

$ |+ q1 n& v9 [% `JDK1.4之正規表示式
' Z1 B3 P/ S; e; ewritten by william chen(06/19/2002)

--------------------------------------------------------------------------------
) G2 Z9 v" _+ z. @& |7 t! M
6 \0 }6 q  F+ Z4 }/ I8 ?, n什麼是正規表示式呢(Reqular Expressions)

) q4 P* n* h; c7 v. ^; }就是針對檔案、字串，透過一種很特別的表示式來作search與replace
( G& q8 x# C. i& ?& n6 d  G
, Z% Z! z% Y  Q/ u% ]% K3 F因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

7 _0 U9 F% I# ^% j+ ^- J所以發展出一種特殊的命令叫做正規表示式
4 y# x7 N2 }4 y6 `$ ?
; C/ j0 G$ q: O) Q我們可以很簡單的用 "s/
' H# }: V8 `# j/ h  r$ Z" E因此jdk1.4提供了一組正規表示式的package供大家使用

; @$ ?% c! d- H( d+ \若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
; d* S1 k4 |# t+ h2 L0 `
" k0 M$ `2 {/ @8 ?- l3 }剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
3 J- E- M9 Z5 T9 I2 }- Y1 m
"." 代表任何字元
% f" }3 w/ R* m
' @! O* d. w2 g, y正規式 原字串 符合之字串
; k5 D/ U" T( x; K! {4 @9 |. ab a
  H8 T1 |" d% Q- ~) u! T2 F.. abc ab

  G1 k6 b6 L9 z. \# p4 P"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
+ ab ab
5 s, |$ ?* a* b6 R0 v3 T: P* abc abc
# d# W, D: b1 i, Y, i; H
"( )"群組

5 \3 C, y+ \; f& T2 v$ y正規式 原字串 符合之字串
(ab)* aabab abab
5 ^5 A7 Z. R0 r# [( d
字元類
8 I. ]5 ?: e6 v/ f
+ k  }7 l- u9 S4 W8 Z正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
" u( |( b2 C- u- ][^a-d]* abe0 e0
( \5 i8 U/ M& S  W) v8 i  l[a-d]* abcdefgh abab


0 C; _) J2 a( b8 p# i$ |簡式
. P4 A6 O1 d+ b7 _: t
\d 等於 [0-9] 數字
) A& b0 W. U9 e0 g1 L0 B% H\D 等於 [^0-9] 非數字
- ~7 q6 i) X7 I\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
* b$ ?' ^( ]9 z: I\W 等於 [^a-zA-Z_0-9] 非數字與英文字
' y- K! `! k6 k" R: Z
# l1 p9 }: b# p+ ]每一行的開頭或結尾
& `8 E1 q) U0 ~* P* l. d
1 \8 Q: H+ h7 a) \; _7 _^ 表示每行的開頭
: V7 c$ v4 ^- w, _( z: r5 J$ 表示每行的結尾

--------------------------------------------------------------------------------
* v4 \" P. G. [- T
正規表示式 java.util.regex 相關的類別
+ g; r4 b- y1 w! s# S1 X) U
Pattern—正規表示式的類別
; X+ j9 U2 C% G9 c& KMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

, k) H# l6 F: w/ M+ k範例1: 將字串中所有符合"<"的字元取代成"lt;"

, \/ R0 F( K+ yimport java.io.*;
import java.util.regex.*;
" H5 y. A$ j0 H2 C/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
& }) R$ R. h8 i/ y+ V# A, {public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
* }  S" [8 U& e; Y( Btry{
% ^1 Q' o) |+ a2 p+ lwhile (true) {
+ i$ W+ p- h. VString line = br.readLine();
6 t; _) W' s1 d1 a2 L// Null line means input is exhausted
if (line==null)
break;
6 |$ [! y! P- w% I0 Y6 R9 ?Matcher a = pattern.matcher(line);
2 R. A" U6 U: G0 K2 {, t! \while(a.find()){
" C6 J2 P" f/ x. f0 ]System.out.println("搜尋到的字元是" + a.group());
9 j* |1 H# q# v) O; v+ |2 o! q) b5 A}
4 `7 p$ q0 S) T/ [' }* HSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
}
% @* b: `. z3 h; Y* C3 B' ]
8 A+ X. e7 o' M7 |8 t範例2:

import java.io.*;
import java.util.regex.*;
/**
* 類似StringTokenizer的功能
/ I5 L& W7 c( q7 ?! `* 將字串以","分隔然後比對哪個token最長
*/
3 r. y% o  L$ _2 n( ppublic static void search01(){
" Z& f! p9 U: C3 }# t) h// BufferedReader lets us read line-by-line
2 N' E; W2 I  x/ WReader r = new InputStreamReader( System.in );
2 I( {2 B7 s( c$ T3 T3 ^7 L! D8 NBufferedReader br = new BufferedReader( r );
+ z# T0 W  p: v' FPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
* \! \' c! H1 d1 |( @% W- O' {for (int i=0; iSystem.out.println("分段:" + words );
; s) Z$ [) l; G8 \) [if (words.length() > longestLength) {
longest = i;
longestLength = words.length();
1 C- f1 c# R* X' w/ U! I* v}
& m. W) `% w4 K}
. b2 V& C: i7 zSystem.out.println( "長度最長為:" + words[longest] );
  g" E# ^% P5 t8 Y8 t}
}catch(Exception ex){ex.printStackTrace();};
}
" o9 f+ U5 h2 }, z$ E
--------------------------------------------------------------------------------
$ M: S7 @, v! z) {- P
" a$ b/ i& |( @4 |$ R7 r0 P# f其他的正規語法

. \6 y! h$ o: B# \/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水