关于正则表达式---ZT

Longe

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

- B% N. L4 g1 ]1 m! @) ^/ E" \支持多种平台
# |8 r; O# |. v! B9 T
6 K$ p/ h6 z, n6 z1 e/ u
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
/ I+ r5 N& `1 W7 c
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
5 @: l2 c+ \$ d% O( \0 y
# P2 X" _( S  q9 f# I, ?比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

/ j8 e2 x2 p  y; Y正则表达式101
9 x! r0 {7 O. S) A) A* t很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
----------------------
: O) N7 k# A' ~1 h9 I2 S) _字符匹配
+ x: j2 v) z% V8 t( v7 J7 D7 L7 j7 ~
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

每一个表达式都包含需要查找的指令，如表A所示。
/ S  ]6 h1 N( A! S  Y
3 k9 C. d9 w" I) pTable A: Character-matching regular expressions
8 r8 j1 S- X7 N3 C格式说明：
---------------
8 m! `. @3 r( b( u! i" x* S操作：
- ?0 P, y; L0 k! |# d( W: K解释：
例子：
结果：
----------------
4 f; H* S6 V. g5 O6 H4 @# H5 _" j! p.
7 s" |0 u/ x6 m3 p% k4 VMatch any one character
. b0 y8 P7 {4 v" S& rgrep .ord sample.txt
( [: F) y% A; Q, n6 X! c7 fWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
! `1 g( B5 a( Y% e" n+ I1 I[ ]
Match any one character listed between the brackets
: }" h* s+ V7 s; W7 o7 qgrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
[^ ]
" Q6 {/ Y8 i9 ?- |Match any one character not listed between the brackets

! A5 z0 c- \' L0 d' Z% Lgrep [^cn]ord sample.txt
. m' x& Z' |& t7 T7 IWill match “lord”, “2ord”, etc. but not “cord” or “nord”

7 X5 O  X# @8 r, h& ngrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
  a" x" h3 f( Z( M
/ {, x$ E  u% G9 Ggrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

9 q9 E' r1 }% f重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

2 U) t1 o$ U  ^9 X; B+ l* pTable B: Regular expression repetition operators
格式说明：
# [/ \3 F% k! j; c( T& J---------------
操作：
0 a0 _' ?& p! z' t解释：
例子：
结果：
----------------
0 o& i6 E% A+ H, ~?
Match any character one time, if it exists
. c. S: a6 ]& B' C  |' Negrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
2 C! @8 l% B4 @0 t: a1 C9 D/ ~------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
+
; D7 A' @! U4 M# i% {; XMatch declared element one or more times
egrep “[n]+erd” sample.txt
& E6 g7 q3 t( c* J& Z' a( pWill match “nerd”, “nnerd”, etc., but not “erd”
! ^8 u' c! Y  k0 `' E- f  n--------------------
, B7 R) V, R( l) S{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
; ~2 g" _9 V, k# f% z# r: zWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
9 I: y: }: t9 @( g/ L( R+ p) _------------------------
8 o& N+ Z- l( Q* g) f/ ^{n,}
  k- A! f, T  x5 E4 N# {; j, g) MMatch declared element at least n times
1 E4 g1 O% y3 K- X( |" a9 Aegrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
7 A. A# B7 g6 y{n,N}
. s, b% Y5 e+ s. hMatch declared element at least n times, but not more than N times
$ N+ x6 W6 y0 t% R! X! M" T: h9 cegrep “n[e]{1,2}rd” sample.txt
  v6 W! D4 O) W/ @Will match “nerd” and “neerd”
; G$ k! Z# d# B! E1 g
0 |; O" V; x) }, ~8 T' J) ?第三部分：
) h. h' i  u3 e- H9 O' P----------------
锚
5 q' r  O( V+ m锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
- c2 B  r: T2 w& z6 R2 v, q. m6 v! c
0 V+ c/ ?: d" ~) Z" S3 O, ^/ q5 [s/pattern_to_match/pattern_to_substitute/
8 Z: f+ A6 _2 Y6 s- I/ M/ |. l( n
% v" g% {" z  D' ^/ K. P7 Y
Table C: Regular expression anchors
1 K+ a, z4 |0 @4 d-------------
% p+ Z6 g! F! X6 F. X操作
解释
4 m+ S* v  o) W  `" a$ O7 L4 j' B  R例子
结果
---------------
( Y$ m- [& U" y% A6 {^
5 q8 R# L  M  IMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
$
Match at the end of a line
, B( H2 h; O5 w$ C7 ws/$/ blah/
Inserts “ blah” at the end of the line
---------------
# J+ h# {9 @; R' o6 i% |2 J  ]\<
0 Z$ D: Z0 S+ \6 j$ J. |' nMatch at the beginning of a word
+ Y& F! \% S+ P& ls/\Inserts “blah” at the beginning of the word
( j2 V0 Y* |1 k. o4 \
4 z/ s3 F7 B6 x# Kegrep “\Matches “blahfield”, etc.
------------------
  V! `. }- a  \4 o% q\>
+ r2 L- {- j6 k- @2 T7 `Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word

egrep “\>blah” sample.txt
- f- I/ ]7 o) ^Matches “soupblah”, etc.
---------------
& n- X2 J, i9 d$ q) k6 h" E\b
Match at the beginning or end of a word
8 ~4 F7 l4 |0 k0 ?% R* c, Megrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
* y3 z" H3 O/ ^! o  b. g\B
$ Y+ r* D' H7 O( i6 b' d7 aMatch in the middle of a word
% a: _$ j+ a7 H( P7 P% Yegrep “\Bblah” sample.txt
+ |8 N, I- X- S0 T* `* ^Matches “sublahper”, etc.

$ M! Q- Y: [) k, \) A5 x& L: T8 P间隔
- ?5 Z# c- s) P; z
) q9 Z; G& p  `! LRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
# e6 ^  _* b4 I6 d" @$ U# k1 ^, x
egrep “(n|m)erd” sample.txt
) x! n5 j1 A6 w- @
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt

$ c9 n; l" m& z$ b' |- I, G, T当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
1 B! L2 d, u* u5 E; d
第四部分：
----------------
一些保留字符
3 F& P7 u) r: U3 v0 ]Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( R" Q2 N7 p# V  \; V) H- t( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
\ backslash
" o6 p* E# M$ a一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

1 X4 L! h" P  C) z1 I5 Seregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
! s- _, y- l, k! v0 c
8 @2 L  k$ h) |( k: |% t9 z总结
! S0 l( c: H* J4 Q) o- e7 y" o7 b0 ?在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
# _0 V) j+ ?9 t$ {0 ^
另外一篇文章
& E: n$ ]) }; W2 R2 M2 ?----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
/ }- x! i  t5 b- u* s5 V9 V类和方法

0 e: [) O6 n1 D  ]+ w' {下面的类根据正则表达式指定的模式，与字符序列进行匹配。

  ~$ {% L- B% d. i" b0 L+ N" P; X/ n7 PPattern类
& m/ J, s& R& J) `0 p8 ~8 z6 \
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
5 d  _) u6 \# r0 ?7 k5 [
) p' ~' M' L8 l, M) m! I4 q用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

( K' B* m) g" F: u: ~$ w用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
) S9 C) k0 k1 U
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
) [8 x: b  d+ E' V) D- P, Z
( L9 ^7 B/ y5 g+ z/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
' B$ e6 m) R, E*/
9 E2 n- L0 I5 j# y, L* ]! s' x2 fimport java.util.regex.*;
: ?9 S1 S0 k" x$ m2 g7 m  f
public class Splitter {
public static void main(String[] args) throws Exception {
+ h! M1 R* W! U: m+ @8 x4 e  l// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
String[] result =
$ Y" S5 t* v, i) B3 Y  F) D   p.split("one,two, three four , five");
% G8 t7 U9 ?6 m& f- Wfor (int i=0; iSystem.out.println(result);
}
; n+ w, s6 J* E3 r  o( F}

7 `  A" s* Y& V4 BMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
; M8 n& e0 G6 A8 V4 b
; _: }/ C% o, M2 \' D通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
' p: J/ |1 h6 P& X
7 W/ t1 |/ }- |  E. }matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
4 q/ g) b7 }; e, u9 Afind方法将扫描输入序列，寻找下一个与模式匹配的地方。

8 q) z" _( P0 Y: j& M# U7 A这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
5 V% R' t' `6 |; w
# d/ ?$ p3 I1 `- H' s' X; `这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
5 u" U, e5 w9 V6 `0 w& P6 o
* N) I4 h4 l( r3 J" I6 iappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口
! ~0 M2 b" }6 P5 ?, R, n7 h
7 z& r0 v% T4 O+ c! O% H1 DCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

Regex情景范例
0 M. ~  M9 R+ _( X( \2 O0 n' f8 h
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
4 b. n& \2 s) E; @
* w, ?" x+ x, Z! U简单的单词替换
0 }& f) v0 j7 V5 X
/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;
- c+ \) _3 s# b
public class Replacement {
+ U( z. m# {* a& `8 epublic static void main(String[] args)
  B- l2 l, A7 z       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
: F/ }% S5 O7 u( e8 |" s! o( l- K// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
' H* M% V4 W9 }5 O+ q7 o3 H/ Fboolean result = m.find();
; W, x' `. d/ C// Loop through and create a new String
" U6 A& }% r1 H+ E* m// with the replacements
) ~, X; ~, U" {4 r$ ]5 l7 i' R/ ^while(result) {
m.appendReplacement(sb, "dog");
& Y. Y- h  K5 ]" X5 j2 Q2 Sresult = m.find();
+ Z' I# @$ ~4 k}
// Add the last segment of input to
// the new String
m.appendTail(sb);
System.out.println(sb.toString());
1 [2 h: [( U! f4 O. Z' e& E1 I' o6 ]}
2 o; E" W" g4 P9 b) `}

* h5 t0 G5 s) x/ U# C电子邮件确认

7 ], l; Q0 v6 b7 ]* A以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
! d) r+ e- Q7 w" T
0 V, X4 O8 E; i! J3 \/*
* Checks for invalid characters
* in email addresses
4 g/ }& M: |9 M* a9 x* P4 U/ h*/
+ K5 T9 f( W8 b, z9 Gpublic class EmailValidation {
public static void main(String[] args)
           throws Exception {
0 f1 @: R- b+ {$ `2 ?" t           
3 J1 E3 l9 ^  f! R# c% C' bString input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
+ S+ Q3 v5 X# Q! ^& FPattern p = Pattern.compile("^\\.|^\\@");
1 \4 p8 g# Z/ W7 ^5 f0 q+ k$ [5 CMatcher m = p.matcher(input);
# n4 B9 Y, r- |* k& Eif (m.find())
2 M8 p+ [5 j( J( b. O, H: FSystem.err.println("Email addresses don't start" +
2 F- T" N8 |% k2 H         " with dots or @ signs.");
3 I! A0 b3 f6 k. H% k5 x$ Z//Checks for email addresses that start with
% p$ j! f: u$ I0 ^//www. and prints a message if it does.
+ j5 o5 s& w" `$ I3 tp = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
: ]1 b8 w5 j: @5 B) FSystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
6 g, v: W2 Z2 w" n}
2 h( a, z/ s8 l" P3 E6 v% hp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
4 f; @, B4 _) nm = p.matcher(input);
5 ^9 S" u3 z; p/ jStringBuffer sb = new StringBuffer();
( }* s0 W7 x7 V( w; z$ R9 lboolean result = m.find();
" v5 d, W. I+ P' uboolean deletedIllegalChars = false;
7 i5 ]+ J* @' b# v. F7 p) Q
$ m- H0 }- y. Y+ Iwhile(result) {
deletedIllegalChars = true;
6 W/ ?! |6 u6 x3 C! tm.appendReplacement(sb, "");
0 t( S4 n1 E  |( Presult = m.find();
9 N* @  x/ |/ E! ^! z}
6 i, D' Z2 {! O
' r  M( w' Y  [* i1 G+ S0 [// Add the last segment of input to the new String
m.appendTail(sb);
7 l  q  ~: Y4 r  g+ J! `7 y
input = sb.toString();

. F3 l! y2 x, Z3 R! k) ^9 Gif (deletedIllegalChars) {
4 K5 E6 g6 a$ R. r6 ~8 KSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
; n. z7 F: T2 n* E) s' n+ M& s}
( a, P& {; @. t2 b}

- Z. Y; c" q) [  `$ B从文件中删除控制字符
. F! n9 T$ K9 |! f! E0 i8 p) |6 g
/ ]1 r$ r) \  k! Q) {, [) ?/* This class removes control characters from a named
* file.
*/
/ p! r7 T2 s2 a& S# g/ h* himport java.util.regex.*;
6 K9 o7 C5 \+ C% o8 ~import java.io.*;
+ J  f* q/ I: ~8 v% S1 P
public class Control {
public static void main(String[] args)
+ L+ p* B8 c: d! @* |) s           throws Exception {
           
- @! `4 \9 a. `- H9 |2 F//Create a file object with the file name
; @- `: `8 P, o7 [+ B* i//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
* j" X, q* f! [6 Y//Open and input and output stream
1 E3 v0 W) B& b8 g! @" f8 Y5 WFileInputStream fis =
$ Z( \/ F9 L9 n# M! p: P       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
, `# }9 s! |+ o0 \0 {9 s
BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
; z7 n2 W; r: w/ ~  f/ p8 {     new OutputStreamWriter(fos));

( Y" \' q1 l% X1 U  y& M// The pattern matches control characters
3 K- c% B! K! s1 D2 }Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
7 E  O/ Z" }' v5 [4 h8 DString aLine = null;
while((aLine = in.readLine()) != null) {
) h  o1 w( w, x# X: dm.reset(aLine);
% E% d$ T; E! j- H. R//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
4 |# r) {2 w! F% k$ d/ m9 I1 _, v0 u- Q}
. D2 {0 A. f! O  j9 e% R6 f& Qin.close();
' w% z/ q% e7 e# q& ~! ^% {out.close();
}
' B1 e  Y4 ~( C. X$ H}
( l& s5 u1 S. m! c
& ?& ^( }5 c, C5 c/ R) Q* y6 r文件查找

% j5 q% f3 _  D% @. r/*
% C$ p  v6 m4 ~+ ^( h" q. E( d* Prints out the comments found in a .java file.
7 O; b& u7 L  r! H* C*/
import java.util.regex.*;
$ M* O2 \/ G1 G" o5 Gimport java.io.*;
2 T4 ^4 b! {; u9 J; Nimport java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
! V+ @: [. M) Z# W
public class CharBufferExample {
public static void main(String[] args) throws Exception {
: o- R, y# c7 G" E+ c. o// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
& |, Z6 E7 S& l9 y; E4 Q
// Get a Channel for the source file
File f = new File("Replacement.java");
! g$ t. h  x5 Z5 `, W1 UFileInputStream fis = new FileInputStream(f);
2 X: @6 H9 ~  a: p, n3 vFileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
ByteBuffer bb =
4 U- u+ s( B* z* c; f+ hfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
7 i8 ~! Y- @& k2 I, [Charset cs = Charset.forName("8859_1");
  h0 a% f: e$ \$ J  }CharsetDecoder cd = cs.newDecoder();
  d) I5 y& ?, _* U# o% z6 k# WCharBuffer cb = cd.decode(bb);

// Run some matches
! n7 F2 C) w+ q  VMatcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
}
) z$ H% X- j3 n. L9 S9 v
结论
' o8 V$ Q7 O0 i& f" T2 H3 l0 y现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
written by william chen(06/19/2002)

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

. e6 i5 C) q- v什麼是正規表示式呢(Reqular Expressions)
( R1 P5 j( t" L& B+ N+ Q* H
就是針對檔案、字串，透過一種很特別的表示式來作search與replace

7 n" _# o' p& C4 K% K+ \) d& ?9 S因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

5 B& A7 J+ R: ~, ~* L6 J% P) s- c所以發展出一種特殊的命令叫做正規表示式
! e6 Q( q8 ?+ K" H2 p
+ N, }* s+ |" I* V我們可以很簡單的用 "s/
' ?& }% E$ ~3 u/ Y3 z3 E  ^' p+ k因此jdk1.4提供了一組正規表示式的package供大家使用
, l# C' K2 C" x6 T4 \+ Y
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

/ H, ~/ j% J$ |剛剛列出的一串符號" s/
* j* ?, W: q3 ]" D+ L適用於j2sdk1.4的正規語法

"." 代表任何字元
* q( C- x5 ]* z# H/ U& o
正規式 原字串 符合之字串
& a3 y  e6 W  \7 j- t8 m. ab a
.. abc ab
; a' s& @- R1 ^+ B3 `
"+" 代表一個或以個以上的字元
# ^) r& z% J9 X; R"*" 代表零個或是零個以上的字元

# ~5 j% t* q7 d5 z( Q( }. D+ F正規式 原字串 符合之字串
& o6 G. `8 D! i8 u4 \+ ab ab
* abc abc

"( )"群組

: k6 c: X, U- ]; N% ^正規式 原字串 符合之字串
& }7 ~2 B4 R3 }% K5 n4 ?(ab)* aabab abab
5 U* U- p. b8 N( N9 a: x
) w4 E( q8 p! F* ~% |8 \$ s# Q7 H* Q字元類

( l0 ]6 d2 }* w1 Z4 A正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
# F/ [/ s( r1 O' ~[a-d]* abcdefgh abab
- d8 o3 T- |& n0 t# G1 v

簡式

& ]$ u' B' F2 s' x1 F\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
1 }, @; I# B. f- a$ q\S 等於 [^ \t\n\x0B\f\r] 非空白字元
' k+ h# r. m' A" s" C, D4 I- r\w 等於 [a-zA-Z_0-9] 數字或是英文字
8 C6 \( s9 z/ T6 _\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

^ 表示每行的開頭
! z; z* o& v% J$ 表示每行的結尾

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

正規表示式 java.util.regex 相關的類別

& w% W9 e/ O3 c0 y: v1 T% W9 e! i' ePattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
  W. ~  F/ K8 G2 L! k' T+ G- T
範例1: 將字串中所有符合"<"的字元取代成"lt;"
& W2 \1 I$ V8 Q) A/ ^, Z
7 r3 ~4 x3 I6 n- o, M8 ?import java.io.*;
import java.util.regex.*;
  M! |8 L4 e8 {/ g+ M. J7 r/**
7 X* d/ ]; P0 R. T+ T/ v& i9 U! ?* 將字串中所有符合"<"的字元取代成"lt;"
5 V" L  }# t7 X6 H: z) ]*/
public static void replace01(){
8 _7 P4 b0 e. [! C$ X( y// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
& H0 P: {" \) IPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
' z$ p1 o% a: j: \0 ?2 a% uString line = br.readLine();
// Null line means input is exhausted
if (line==null)
& ?* ^+ o2 P& ~0 ]" _" ?8 Bbreak;
Matcher a = pattern.matcher(line);
$ Y5 L8 j% j4 z! L4 twhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
' Y9 P9 j& F+ n  K7 ~( y}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
( \! T; i/ T! \$ v/ Z2 ]7 J8 X* l% a! [}
7 |& M* d4 a5 M2 W( E}catch(Exception ex){ex.printStackTrace();};
5 w2 Y( N' K5 K* ?: X5 Y' d}
: _: d2 o! Z$ U5 D2 Y5 D; j2 x) i
5 o/ y) |% F4 I+ v範例2:
) \! L8 a: p# ~; \# }
import java.io.*;
* O9 I& Q4 k# _' e( uimport java.util.regex.*;
: ^5 U4 V5 H  g# ]/**
4 h3 |: g: e$ P) f3 g( g. a" j* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
; Z4 ^4 l9 K* O8 S8 n! Mpublic static void search01(){
// BufferedReader lets us read line-by-line
- a" T* s, L6 O1 oReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
' z8 ?  t8 @& a  t2 G, {- ^Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
5 ]) r& ]. z/ _# C- D/ Ttry{
while (true) {
: Z+ [3 [/ Y+ G; I% p' aString line = br.readLine();
String words[] = pattern.split(line);
$ Q, P6 S2 o6 Z. m// Null line means input is exhausted
9 W& O6 j% z" B2 {1 Tif (line==null)
) m6 W3 F1 B! L+ r$ hbreak;
  o* f6 g. g# t& W: t// -1 means we haven't found a word yet
0 Z* b" n! H# {) Tint longest=-1;
7 D3 J& N/ W* b, F% M2 }int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
% w6 g' p1 ^$ F4 J; {# G% y" llongest = i;
longestLength = words.length();
: ]- e4 ~; N+ G/ x}
  {* A9 p  ]5 O6 W. o6 {}
System.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
$ ~! R, z3 L6 Y# R0 z( f8 K}

- v/ `- }9 H9 v--------------------------------------------------------------------------------

其他的正規語法
6 M- _' H0 P8 _# W9 h
# o5 C$ ]0 l" g  J, t/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水