关于正则表达式---ZT

Longe

第一部分：
-----------------
' A' K  Z  b7 D8 c6 l正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
/ q7 t5 b# u3 g4 r7 m6 v! Z- @) b
, @$ }7 C+ b0 I. L# `支持多种平台
  i8 q. \8 W! F( R4 F

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

1 X' h1 Z% \; R% C正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
4 t* J. E$ [  p8 o% Y& C
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

! {1 F$ h7 L2 _+ K比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
7 y0 D$ Z( N5 h" k+ j" U2 j
正则表达式101
8 @7 n% H& ]! A2 I1 r; U很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

# C1 F0 n: K8 H& z第二部分：
0 g9 ]  h. {8 b- ~6 G----------------------
" y- N, b) A0 b字符匹配

% O& J. s3 V" |( ?; H: k/ V8 V正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
  {% u0 ]( S7 N
每一个表达式都包含需要查找的指令，如表A所示。
7 Q$ \$ b0 y- B3 j4 r
Table A: Character-matching regular expressions
; r: J2 B4 B' I% W' D( L9 J格式说明：
* I; H: h. ?& s4 Y' M- f; V: k- v8 |---------------
操作：
解释：
例子：
结果：
, z; m% g* e. [+ G7 q----------------
.
  P4 P+ n" b; D0 K$ KMatch any one character
. X7 |- r" z) U' d' ]9 dgrep .ord sample.txt
% L6 Y) i) i% _* D7 Q' V7 {Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
Match any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
$ ?7 j8 H# \  u; n: T) ^[^ ]
' q% Q% j8 w( z0 AMatch any one character not listed between the brackets
+ |0 Q* y* {5 O% n
grep [^cn]ord sample.txt
4 Y! A& z) ^' @Will match “lord”, “2ord”, etc. but not “cord” or “nord”
( S( s4 q- f0 H7 n
! A' `8 p( V8 s. a" ggrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
7 I& R3 w8 H5 `
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
- Z& t. Z4 G: L) d& k格式说明：
; L9 o/ o( }5 _8 x' U1 p---------------
4 }" X+ z* m1 H7 T/ G1 j, s  S  }操作：
解释：
% h3 Q  A+ {* E7 X例子：
6 O* ^8 g4 I/ o+ t' B) h. K' G结果：
$ ?* f8 @! Q, w  T----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
1 t( [/ ^( n! V6 C' _5 C  P7 s% B*
Match declared element multiple times, if it exists
) P: E8 @/ i; gegrep “n.*rd” sample.txt
5 A8 S2 c' v. m9 n, FWill match “nerd”, “nrd”, “neard”, etc.
+ \$ O# {' `8 a5 A1 p-------------------
8 N' D$ b) m6 }( I1 v* F$ w9 k, Z+
" K( Y' s7 N) p9 X2 CMatch declared element one or more times
" p$ h- x' c! E& C* J/ I, tegrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
' H/ V( X* w0 |7 r+ \; _2 X' Q5 S--------------------
$ M. M, R0 j( m7 u, K* B& I" N{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
# G+ W0 s! c( J$ pWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
  {) ^! i! l) X8 E' o------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
& b& O9 S1 x2 T) m1 z. |Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
. m0 W% g1 K3 A! e{n,N}
7 j' o. m( d3 d( C* {5 U; GMatch declared element at least n times, but not more than N times
  t, L: |! }% Y# F4 g# Iegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
1 i1 n* N' g. f0 n' r# h( S; n
: a, \" H! P; g; ~+ a' x第三部分：
----------------
锚
. E8 t6 T8 o; K& C7 \* ~锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
0 T& F0 }: T2 d. z! s1 q
1 Y6 I1 X: R; v. a/ R; N, ns/pattern_to_match/pattern_to_substitute/
2 {( A: ^! ^: P7 a
3 R5 W  L/ U- b3 _, Z
* p2 {. `. _/ y" O* l" n9 i) NTable C: Regular expression anchors
& |1 j5 _8 p# q0 ]: D! d' L) W-------------
操作
& k3 i2 \/ G5 r6 U  Q* q3 T解释
例子
* D; _5 h+ N1 [- G% ~结果
---------------
0 R3 X/ P0 q( c# g, [7 S^
Match at the beginning of a line
s/^/blah /
" }8 A7 k; c% Q- i# \' r: GInserts “blah “ at the beginning of the line
---------------
$
1 h/ ?* c0 _: s  T- X  SMatch at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
) e6 k; ]& J2 V6 o2 R3 `---------------
\<
, x( c- t, w" x* EMatch at the beginning of a word
% X! i7 {$ N5 y7 a, K0 c7 J' q+ L* ks/\Inserts “blah” at the beginning of the word
* \% N# _! j( L8 P
6 D" o* |8 p! a  G4 d! O: cegrep “\Matches “blahfield”, etc.
------------------
; A+ y! A% ?8 O\>
Match at the end of a word
; i* m$ p6 z! Q; W/ t& zs/\>/blah/
Inserts “blah” at the end of the word

9 ^6 u  s. r' S# R: D* J+ tegrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
8 w: `3 @$ H9 L\b
Match at the beginning or end of a word
5 G9 X3 G' ^9 z2 C5 D# e/ Uegrep “\bblah” sample.txt
' y$ j3 _) N9 [: ~Matches “blahcake” and “countblah”
$ B( G1 I* S5 M9 n+ h-----------------
: d) i  n, w( b+ p\B
/ X8 s$ I* |* r  R1 y4 A. ]  _9 zMatch in the middle of a word
# n) d, }, z+ s/ Aegrep “\Bblah” sample.txt
Matches “sublahper”, etc.
3 c3 u1 h" R0 [9 T* a
间隔

& \) v2 }/ F) E+ G* K+ P& sRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
& B0 V3 @. e5 s3 C! i+ `2 K* W/ o
egrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
4 \7 l# h0 s/ u6 q  |8 E. r# {/ c
egrep “[nm]erd” sample.txt

% s5 [: s$ a" S& H: z当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
# o: z3 @; ]: n- y; j# h
  G4 n* w% @6 v* R第四部分：
----------------
一些保留字符
" l7 D; n( o2 hRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

* y; r4 v) k7 S  o/ B3 i^ (carat)
- Y* s* t$ D) h. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
; j8 G) Z$ x( ^) Q) T# a8 T% P8 j| (pipe)
# J# u# u, N6 [: L* (asterisk)
+ (plus symbol)
, b+ n/ w2 [  J) K! R5 f9 O) y? (question mark)
5 m' ~( X6 Z$ i4 Z4 ]- u- G{ (left curly bracket, or left brace)
\ backslash
# B- S# o. ^" r0 }3 i$ F一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
  d* {! o; _- X) u4 J4 O
- F9 \8 X6 p0 ~2 [: z4 ]eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

+ |" D; z4 K+ \+ ]6 m. k总结
+ T& R9 `* F6 f) K5 a# K. D在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
! f2 L8 w2 \3 I9 m) }7 z----------------------------------------
! _0 z/ N( }! o6 \" N( F& y正则表达式和Java编程语言
-----------------------------------------
类和方法
. B, X- o( P! {, I# y
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

4 l/ w) c) Z+ V& B( [  yPattern类

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

% j- r! Y# H& Z5 @用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
+ p0 P) |4 m; @6 a
8 Q* i7 g2 ^. B5 X0 D6 N4 [+ h/ hsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

9 ?# e1 L; L9 A% |3 Z+ t  V/*
2 H# L6 k* Z, X* t0 a9 W& c3 D* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

. e9 z3 p2 w# p; f/ q  Tpublic class Splitter {
public static void main(String[] args) throws Exception {
) p5 b5 x: i% h7 y/ g- N; J. L// Create a pattern to match breaks
' ^1 Q9 {5 c2 F% l1 E8 [7 H% ]4 QPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
% O! Z/ r. m2 T3 aString[] result =
   p.split("one,two, three four , five");
4 c# d, \6 l& A: D+ R0 yfor (int i=0; iSystem.out.println(result);
}
}

$ n& M: t# Z! T9 N: YMatcher类
- I3 b% M# y, @& V6 j6 t# h
( @; s7 ^; S! |: u# `2 hMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
0 w/ e- T- _* }2 P1 I( ]
1 w) ^8 s0 `2 y# Y) [( u" D通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

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

! m$ i6 r: p5 y7 R4 N. J0 a" }  q# S这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
) N9 O( L' h4 K6 e7 [
4 c% ~: ?/ P( R2 NappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

* f6 w* j0 k% N2 \' s: V5 f例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
; M% o  m+ {& Q; Q, N9 u! i
( v; t; K& u  Q9 G; yCharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
& f% A) P+ N! N, o% t
Regex情景范例

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

简单的单词替换

3 L  [  L1 W7 o% ^/*
* This code writes "One dog, two dogs in the yard."
  P. X/ f. P" d5 {# }" p. r* to the standard-output stream:
# h3 e3 a: t1 C: i! A: E*/
( k. `4 v# L" o$ nimport java.util.regex.*;
. [1 }( _8 C7 v6 s8 u  F
public class Replacement {
0 S; E* m5 [$ z" A0 P4 p: c- opublic static void main(String[] args)
       throws Exception {
5 L6 D8 d% r$ \0 p2 H  v// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
& \; Q' T3 ^1 T6 N7 t// Create a matcher with an input string
& B0 x# i+ r, Y. x/ h8 EMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
) |1 U, y3 \; V0 P: Hboolean result = m.find();
8 Y( K+ X& o6 L- [; {3 G1 m// Loop through and create a new String
. [0 `: J/ A% v+ G" {$ s// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
. u$ Z4 o3 O5 Q( V" A* H}
4 _% Q$ r! Q8 x$ Y1 E! M2 e// Add the last segment of input to
: t9 m9 @( q" G2 \) P* b5 m% e' i// the new String
m.appendTail(sb);
System.out.println(sb.toString());
}
}
7 X! x) }5 @2 ?/ c+ |0 y
; Q9 g9 S- f  \电子邮件确认
  H+ }$ W3 l2 ?
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
4 [3 s0 V# N* ~' V! u6 g
" A% E8 N  ^8 r0 ^( D/*
* Checks for invalid characters
- ?9 ?* J, G1 ?' e# n' l7 T* in email addresses
( I% F$ A) J3 ]7 C7 R! X9 _7 A*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
6 u; b' O* M# E4 M" G( J6 K//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
( {" R9 r5 O5 Y! ]; VMatcher m = p.matcher(input);
2 f- W) Z0 _2 M  yif (m.find())
System.err.println("Email addresses don't start" +
8 o% l( N1 J8 e& y         " with dots or @ signs.");
8 @) Z* n6 v! I  w) \8 H% s//Checks for email addresses that start with
8 ]! G4 K. ~5 C6 z; R- {//www. and prints a message if it does.
$ p% C6 \( t2 C2 `6 U8 v9 Bp = Pattern.compile("^www\\.");
1 v5 ~2 W; T9 ~7 L8 ^( zm = p.matcher(input);
if (m.find()) {
) j! F1 [* h* TSystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
/ i# a) `' r7 N: |; aboolean deletedIllegalChars = false;
$ M, p. S' h$ o' ?+ O  T: t
while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
3 W" f* d; |- _$ V2 z9 y' tresult = m.find();
}

% ^$ J4 u; J& W$ k; K1 t# e// Add the last segment of input to the new String
/ R0 m% q& Q( y% R/ S8 |m.appendTail(sb);

input = sb.toString();

6 q& A  ?9 g8 ]1 Y3 |3 e+ Sif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
}

! U: N! k+ v4 d8 m+ `8 r- k从文件中删除控制字符
6 f% Y% g2 \6 y' G/ A0 V0 F5 I! Y
/* This class removes control characters from a named
* file.
/ S2 f2 F4 z; m4 m1 q( W*/
import java.util.regex.*;
( b3 z' b# k0 ~9 I# ~/ Wimport java.io.*;
( G' a/ A5 R0 {6 U& U  ~9 v
  y- w& z, h+ k( n) P/ e6 }" r. ~public class Control {
public static void main(String[] args)
% w- X( y: f0 L3 O           throws Exception {
5 ?+ Y* N( h+ \7 x9 G& B# B           
1 G" ?$ a0 @1 H7 T+ O4 e( l& T8 K//Create a file object with the file name
+ E& ~% W* K4 [- x//in the argument:
File fin = new File("fileName1");
% G6 o& `& A. j. n  BFile fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
- S" K( l# h+ y4 m9 ^8 j; h8 F& y       new FileInputStream(fin);
; K# Q3 x. V- g/ b" ^( f  p3 VFileOutputStream fos =
       new FileOutputStream(fout);
/ K) n5 \4 s, H7 q
BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
% Z$ z; r9 Q7 b. pBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
3 |+ g6 m* C3 U& V% H
; @4 M* p0 D0 v( h" o+ b2 }4 p  A// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
6 R  P! K! C# w1 tString aLine = null;
; b1 c, o% f6 p' }while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
( s' [* A) n- I" j  ^& {1 E3 _String result = m.replaceAll("");
$ B  Y- T+ W; Fout.write(result);
0 q# E0 b2 w# r( p0 M) Xout.newLine();
}
! t! k5 z! _( P0 ^! W% J+ U3 n9 Win.close();
out.close();
1 Y% n" L8 `) m}
}

* ~! P$ a/ B/ }/ Z+ b7 b6 d文件查找
3 L0 e; B) r& {$ M* u% v- _
/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
$ g! R$ q5 D! i  |# W9 v2 ~2 @! r
( e0 C' t  x- _( Xpublic class CharBufferExample {
public static void main(String[] args) throws Exception {
: y' F2 O4 l6 D4 A// Create a pattern to match comments
Pattern p =
. P# E' P* Y- U6 ~" MPattern.compile("//.*$", Pattern.MULTILINE);
6 A' R( k# t& ]2 E7 h" g: @$ x
3 P$ Z1 X/ \% W3 I" q& M// Get a Channel for the source file
File f = new File("Replacement.java");
) k& Z: G- l8 T! {) e  yFileInputStream fis = new FileInputStream(f);
( G% m; m  |* c. G& B4 M; {1 kFileChannel fc = fis.getChannel();
2 U1 ~% D3 x0 t) Q8 g: ^
0 g  n8 P( c* M" n! z: l: r// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
6 ?! Z- l- |0 R6 o8 H1 t; [Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
# H, |. b0 }5 `/ ], dCharBuffer cb = cd.decode(bb);
# [8 ]) J1 O4 N6 J; D
1 `" W$ X1 c/ s// Run some matches
- X# z  Z) r) C: d' AMatcher m = p.matcher(cb);
( U; K' g% c3 \6 ^while (m.find())
$ N6 x3 p# D: \# G  BSystem.out.println("Found comment: "+m.group());
}
8 l+ y4 \/ V' K}

结论
0 u( W) R- R# H/ L3 K+ w现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
! S, _( M% o2 [- k- ?! ?( N( u
1 z" x  t; S1 R! d1 T  W  h1 }0 gJDK1.4之正規表示式
1 m- ~9 ?+ ~0 Awritten by william chen(06/19/2002)
! f$ U# R- M4 k0 Z+ j# N& z
, i2 h% s! {6 E+ V  W--------------------------------------------------------------------------------

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

& a5 B7 ~! }& p  z- Z: t1 L3 J就是針對檔案、字串，透過一種很特別的表示式來作search與replace
- I, g7 ?( I& c  O) U# N
因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

& z& M. `( g. p6 b所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
5 d( R5 h0 G; S' E" s8 l因此jdk1.4提供了一組正規表示式的package供大家使用
1 L! o! ?1 ~& u
, ~  m' v# g! t" F- U. ?8 \若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
+ V# ~( @  q3 s
剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
+ f# S7 f; G- d5 n/ a
"." 代表任何字元

; R  V! S0 M5 T0 f! d! e正規式 原字串 符合之字串
. ab a
.. abc ab

. L; |  b. X  L) }* u"+" 代表一個或以個以上的字元
/ q4 p" I5 k7 Z" w0 x8 D, Z) H"*" 代表零個或是零個以上的字元
( X; U* ^9 i0 O! X' W: v3 b1 K' F% A
( R  N$ O/ @; M9 e, f1 r3 e正規式 原字串 符合之字串
4 L. Z" N$ ^- E+ ab ab
) c9 n- l- h/ b) ?  P. s+ m9 e* abc abc
# R$ `% f: Q" {' U: g4 D) X
"( )"群組
! u& p+ Y3 X$ s- G, M% a
正規式 原字串 符合之字串
1 i1 ^# n. F. n(ab)* aabab abab
& b  h; ^3 W5 F! G* O1 P4 o
  b! s* \( D2 ?) x字元類
" h, C1 t. A2 g: E& w: ~
正規式 原字串 符合之字串
2 K7 \7 e% F) d- m( ~. A0 \[a-dA-D0-9]* abczA0 abcA0
+ C1 I$ w: b% @8 x[^a-d]* abe0 e0
[a-d]* abcdefgh abab

1 k! b; b6 G- U5 t: i% t! W/ L
簡式

\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
: N+ r# h: p5 T; U: V8 U\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

$ b1 F" v) P/ k/ \8 x^ 表示每行的開頭
$ 表示每行的結尾
0 Y2 W# X* T2 v# l0 r* {) Y% @
--------------------------------------------------------------------------------
! h, R& z5 u5 ^, ?. {2 z
正規表示式 java.util.regex 相關的類別
5 A6 M: `" `5 k% M
. {3 q+ k- M9 `2 Q6 L8 BPattern—正規表示式的類別
Matcher—經過正規化的結果
* c3 }. B9 y! z& i( ?PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

; }+ a' p* B0 C4 P! a0 t6 e2 K4 N範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
1 ]) b% Z8 J3 y" j5 b! f2 oimport java.util.regex.*;
/**
1 q7 u9 g) M# X* 將字串中所有符合"<"的字元取代成"lt;"
*/
" [: B# ~+ ?0 Fpublic static void replace01(){
3 `1 H* J! T5 V& x+ y9 Q+ H$ F- E* O* w& @// BufferedReader lets us read line-by-line
$ L$ _" L0 Y; L. P! ]' u' K7 ZReader r = new InputStreamReader( System.in );
. h- A7 R' K% mBufferedReader br = new BufferedReader( r );
+ f7 a. q- h/ _# x% yPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
String line = br.readLine();
' |0 B* p( K9 r% N3 i4 @// Null line means input is exhausted
if (line==null)
6 p# D6 F9 {3 r) ]4 }# o5 x: Ebreak;
. V( R0 Q3 O5 r" gMatcher a = pattern.matcher(line);
1 p! Y3 b* x$ U% c( X% }while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
7 ~+ y) w" G" \) {7 i; \System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
$ p. |2 q& b" f}catch(Exception ex){ex.printStackTrace();};
}
6 X+ T" N# P  M
3 {) k! ~7 I2 J# s+ }$ @* x範例2:

: ?0 ~9 E5 v3 J# i/ a! @import java.io.*;
import java.util.regex.*;
/**
% M" ~5 H* `. k0 E: U* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
8 h& J( O- q8 f( Q; _: M2 g+ r9 R*/
7 O) u/ d; `- C) E! F7 K! X) V1 Zpublic static void search01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
4 r" o3 z, R: gBufferedReader br = new BufferedReader( r );
  ~( f  u1 f5 s& D- p: F# YPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
- ~' u8 X0 P  o; N9 f9 J# S; i8 Etry{
while (true) {
8 z. }, g9 e! X! |String line = br.readLine();
: H/ C: z5 `2 u# l, DString words[] = pattern.split(line);
' e; R" s* A  M% T// 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;
for (int i=0; iSystem.out.println("分段:" + words );
0 O9 `3 k/ U) \2 i8 J& nif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
2 P3 i* y" k! Y4 v, B, y' a}
  j* \9 D4 J3 F9 Z! Z2 I}
System.out.println( "長度最長為:" + words[longest] );
# [' F& k9 H' `8 Y, Z( u- F! n}
}catch(Exception ex){ex.printStackTrace();};
, _6 j6 h) L" K0 q( U}
" r0 R% G# J! Z7 M5 j
0 J- h* I$ f. s* D--------------------------------------------------------------------------------

" ~& W. L! d  \& c, b8 z3 Q9 v- |其他的正規語法

/^\s* # 忽略每行開始的空白字元
  V; C; t" C# d2 J2 |7 `/ d" i( l(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水