关于正则表达式---ZT

Longe

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

支持多种平台


正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
; x) u& N: o9 Z
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

5 q. o9 P& R2 X2 L2 ]) ]许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
2 _) m& V  E  Z5 U: r
比你想象的还要普通
) z% P" Z! F* S3 q" f. }2 Q" L/ W随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

正则表达式101
7 R1 X6 o3 F7 `0 ?' H( ?很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
" m0 o4 Z% E8 Q----------------------
字符匹配

* k2 \2 ]9 X9 G# b" r3 Y& n; X$ O' y正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
0 A6 P% Y5 `6 E; b2 j: ^; C
- U- q5 G5 x. D4 q1 g; k每一个表达式都包含需要查找的指令，如表A所示。

Table A: Character-matching regular expressions
格式说明：
---------------
操作：
解释：
例子：
结果：
3 ^4 _; h% D; y' H& f----------------
% l, _0 A7 `" R+ Z  ~6 f8 R.
Match any one character
grep .ord sample.txt
( J- O  W9 w. \/ b  R- M4 jWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
! a% i0 f8 w0 [* Z[ ]
- J, z- G$ p: m4 `9 L5 i5 Y% kMatch any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
% u* `& @* m2 F9 d# v9 b---------------------
: b4 m- m* z+ k( t& \5 B[^ ]
. b& G4 p6 h0 f* i7 fMatch any one character not listed between the brackets
0 z- b  a3 x+ ^9 ]" M
grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

# P0 e; V: Q  p8 ]9 Q9 Ugrep [a-zA-Z]ord sample.txt
% z! Z2 ?) o: `$ p! T2 R( ~Will match “aord”, “bord”, “Aord”, “Bord”, etc.
- ~7 |6 }6 V  P8 q" d
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
4 T% E/ j4 r3 \+ Y! D! X8 f
- P+ E+ V" N" u: U6 f0 c0 n重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
6 w0 W/ c& h3 M' t4 E- Q5 W
- M7 m( S, k: B4 mTable B: Regular expression repetition operators
& N- X& G; w# J' ^格式说明：
---------------
* c8 d+ o0 V8 u$ k( r. w& [8 F操作：
" b& z5 X  o- ?. v5 e/ R/ x& Z5 P解释：
例子：
4 }4 o% L. V0 Q1 S结果：
----------------
* y9 b. y, p# {; a/ C2 N+ l" L, ^?
Match any character one time, if it exists
1 ]  b) _- m3 F; @0 W$ k) c8 Kegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
2 [3 o4 I  n1 s  V, _*
) u. [0 n3 K* LMatch declared element multiple times, if it exists
3 S4 J& C' r+ _0 F* Aegrep “n.*rd” sample.txt
3 x2 U" f. K$ K8 |; FWill match “nerd”, “nrd”, “neard”, etc.
8 \* T% y- |3 p8 X8 \-------------------
+
- W* C' u5 n" e& f+ s) B$ dMatch declared element one or more times
' L3 }3 _# ^  N* ^+ h$ _egrep “[n]+erd” sample.txt
& @" _) e. |) TWill match “nerd”, “nnerd”, etc., but not “erd”
: ~7 j1 Q1 g  u& S  R! ?' m( Q* V--------------------
) X  _, j" k6 ?$ N" }  g$ u8 X{n}
% a" Y. F2 V' a. N" o& b: E# hMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
- @7 l. |2 r" |, n! h1 a' KWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
Match declared element at least n times, but not more than N times
- _1 s' u2 w% G2 F  ^9 W/ C& oegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

第三部分：
----------------
: ^' I# j) j0 W8 ?锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/
$ _$ j  W+ \6 k3 w$ U# @2 H5 V

. _3 y4 W9 E6 `  K) g4 G0 v+ ?0 uTable C: Regular expression anchors
( D# M, q4 }' X-------------
操作
& m& o  h/ k( k: ?  f: M! _0 w; U4 ]! s解释
/ M9 W/ Z, P0 O例子
9 p. p- B* T* Z1 h结果
' y$ X( G: U3 t2 V---------------
- y- V7 `3 t, A^
3 J# L7 k: ^- F6 Q. z3 RMatch at the beginning of a line
s/^/blah /
) W) {( |$ [& p/ ~0 J& J- dInserts “blah “ at the beginning of the line
---------------
8 H$ M- H  ~. R8 J1 [$
1 N# r  D8 w, _! t( V) xMatch at the end of a line
s/$/ blah/
3 O2 G# |$ D. F# F8 v- AInserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

/ A+ S/ u6 e& b! ]egrep “\Matches “blahfield”, etc.
' N9 e4 d5 ~5 C- I; J% B------------------
7 G4 z2 K' ^( F4 m$ U9 h& d\>
) [  K% E& Q% p0 M1 S+ kMatch at the end of a word
s/\>/blah/
7 V# O+ ~. I: D! R7 f2 BInserts “blah” at the end of the word
8 A& k& w" l0 f3 F3 k, M6 A
egrep “\>blah” sample.txt
0 A3 d* v1 p- ~4 T9 ?% f; t- ZMatches “soupblah”, etc.
---------------
\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
, ~  U0 A  N1 k* Z3 M6 J5 p+ HMatches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.

* [' C$ _# {; r+ D间隔

# e: q  ~3 w) U; ]0 O! V, [& RRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
, j) R/ |% m+ {8 a2 P: @2 D7 b
egrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
! R1 E4 [; U) ?
, S- D8 a( i- T* f9 e! m+ ?egrep “[nm]erd” sample.txt
% P) U7 U4 u5 {
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
* G& ?* D* F7 H, O/ h1 P
9 r1 \7 \3 u5 p$ A- b第四部分：
1 u2 y/ B" q1 x7 _# N----------------
一些保留字符
2 h- P# u9 A: j9 Y7 mRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
4 E3 s. @5 x5 p  x( _2 y
9 {7 N% a' ]& d& G6 L/ z^ (carat)
2 H6 b& f# R! F9 t3 y# g4 k. (period)
) b/ k1 z$ b  y) J7 U[ (left bracket}
$ (dollar sign)
( (left parenthesis)
% k  ]" K7 Y% q! ]3 Z1 P" y) (right parenthesis)
| (pipe)
! W; V# i/ m3 N2 i* (asterisk)
' a  S, Z  x; J+ (plus symbol)
7 D% ~8 X. a7 T& K$ @6 N* N0 R? (question mark)
/ |: X# |1 J3 J+ {{ (left curly bracket, or left brace)
\ backslash
: F) N4 r" U. T- W4 ~- c+ {8 x一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
+ f+ ~8 J- Q1 z* p% f0 _
+ w! {# y: z* p8 `/ P% V' aeregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
- h3 f$ I! F% K$ \  h0 ]
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

# `( |) _* p7 z% C总结
0 ?. g6 F7 t. x6 L' ]0 A4 R' E在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
4 z" v7 @, v8 t* a----------------------------------------
* o# W2 Y, h! S& e! ^" d正则表达式和Java编程语言
-----------------------------------------
类和方法

1 I6 w' n7 B! Z' M. J7 l下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
' d' \& \6 b. C/ N4 x0 N+ E
2 p& s$ v0 u7 Y  b- e2 z# B* ~# ?: pPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

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

6 C: c$ @. e9 @, [用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

# W4 Y) F5 x; Hsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
2 D3 s. W4 K, A" I  N; E
! o0 {  c2 w* A1 y+ y9 Q7 O/*
; m! q% U5 H* K8 b1 S* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;
' t- a( y6 w2 \+ U' n4 @; M8 f
public class Splitter {
( H! r" {0 C- j) X1 E9 }public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
0 R8 K* m& ~/ ^% X5 Q0 ^3 X: @" CPattern p = Pattern.compile("[,\\s]+");
) h  u* \- M0 _0 b" j8 w// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
9 }6 e7 a: m# e! s}

; r& v/ X: G. ^9 j4 CMatcher类

# \6 n, `# e, OMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
7 ?$ Y1 V  j% A
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
+ ]; s- ^2 E, H6 O" t" |' Y- x
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
$ O: J8 ~* m% c% O, M7 C
% N" x2 t' X+ S$ ~. n例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

& S* ?4 S- _, n* ]5 c2 E, aCharSequence接口

$ A1 o" ~$ \! h* ?CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

' W" y) ]2 B. G( L( m( wRegex情景范例
3 A) ^6 Z; Z0 E* j
5 e4 Z/ z, B8 k6 a以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

6 e* ^& l! k& G/ ~简单的单词替换
, p* t8 S- q4 b. D4 W& D0 P
/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;

1 H0 J7 B$ z% S" cpublic class Replacement {
public static void main(String[] args)
7 L, H5 j; ]* e7 s4 M% F: B       throws Exception {
$ W. G" L: Q& J0 I- T! v/ ^// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
  C; d4 V  w( r. Q# W5 I5 A6 m/ b" IMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
8 p7 W8 u, J6 G+ B// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
m.appendTail(sb);
7 D% W$ ?9 k- p: m1 K% U: ^2 pSystem.out.println(sb.toString());
% q: j! _3 J5 ^7 ]% ?2 _}
- B0 }5 i  v( e+ i* T9 @% s}

电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
# A+ M  ~, N' u3 f- y* d: a# d
/*
* Checks for invalid characters
* in email addresses
*/
/ D" D4 ^7 B) Npublic class EmailValidation {
public static void main(String[] args)
# n& I/ m6 h* G+ x) X, j           throws Exception {
& h/ @2 A: h8 R" Z& J+ Q           
String input = "@sun.com";
//Checks for email addresses starting with
! B5 }9 I0 O+ o* R//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
0 c8 @& X% h  l" Q, R( O8 ^0 }Matcher m = p.matcher(input);
- L) H' j9 a  lif (m.find())
. N" ]5 P% V. C) _; f7 h: y" h) vSystem.err.println("Email addresses don't start" +
3 o# {8 \4 B3 J: P+ @' Q         " with dots or @ signs.");
& l1 ?" y/ J6 B9 f$ d  _3 s//Checks for email addresses that start with
//www. and prints a message if it does.
0 G& l8 k. J- ]6 u) d3 s6 J& xp = Pattern.compile("^www\\.");
m = p.matcher(input);
: s& u. H, Q9 a# Z# U8 T7 Hif (m.find()) {
0 V3 [' }& v; u$ a$ ESystem.out.println("Email addresses don't start" +
1 V( c' x1 F- @2 ~. O   " with \"www.\", only web pages do.");
1 E( X5 j, \( ]0 f+ _3 R& F}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
- H- Y, j8 D" bm = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
9 K& @4 f: q2 J0 s: c2 y8 @boolean deletedIllegalChars = false;
0 @9 |5 `/ O) M
8 O  t: z! u# Hwhile(result) {
$ y# M* t# c0 G5 o+ ydeletedIllegalChars = true;
6 ]" P& a9 J2 Nm.appendReplacement(sb, "");
result = m.find();
# I. ?# A7 P/ A; U4 T}
! L) |7 c) f" [1 P+ C- J% ]0 h/ |
; u' [( d5 G5 u, O2 ]// Add the last segment of input to the new String
2 N) s/ g! ~% om.appendTail(sb);
$ U! f. T; e; N& @& X. W
1 e) W2 Y& g$ D9 U& iinput = sb.toString();

. O. e2 {2 L# @. e2 k% Lif (deletedIllegalChars) {
& E3 W8 v1 @. H+ U  hSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
6 g- B8 q/ j; ~0 ~5 ^1 d9 p3 w}
, a2 [3 w$ P1 }  l) V) Y5 i}
* z; Q& d2 Z+ w}

  t# ]8 U3 ?' B. ^! _. T从文件中删除控制字符
. q8 O' O- W4 E) \/ {! |  L
/* This class removes control characters from a named
* file.
1 E6 z' J" C3 O*/
import java.util.regex.*;
import java.io.*;
1 Y+ x7 W- q; T8 [  o! }9 T9 T/ ^* t, X
( t& Q+ I2 T( _3 n: Mpublic class Control {
public static void main(String[] args)
* v, ?  N2 B7 `9 w+ e0 m% [           throws Exception {
           
//Create a file object with the file name
% V' A$ I( Y! I# i  V. [" B1 Y3 F//in the argument:
2 S# h7 m5 r8 d% ~- tFile fin = new File("fileName1");
File fout = new File("fileName2");
1 a$ I0 n/ S! s//Open and input and output stream
) y; L$ A6 N8 {7 I. _  S# y' Q/ {FileInputStream fis =
       new FileInputStream(fin);
% ]; T6 h* R! Z+ GFileOutputStream fos =
       new FileOutputStream(fout);

, l. x, k" s; \2 C5 W7 y* ?BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
( ]9 P7 \8 D$ T
" C& B/ Q+ c! a* S/ j// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
4 o" {6 w$ k$ X% e' v  Bwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
7 _0 k5 B8 b$ o% L# A5 S6 L//Replaces control characters with an empty
7 K6 ]: W4 u: q, j* A8 @5 S//string.
* |! \) a8 x! F) }! {String result = m.replaceAll("");
" \+ Y& N0 D0 |; o! l" a7 ?- dout.write(result);
out.newLine();
}
in.close();
out.close();
}
# \1 U. o+ o$ d3 N! D}
  R+ i" u0 V3 @% Y# f& z- k
  w6 o$ W7 r: P8 J( n4 }6 Z$ n文件查找
3 L0 R1 w4 }4 P4 d4 ?
' S# @: h: A9 B, `8 a' M! [4 L9 e- E/*
/ H! k# Z' l. c( E9 Z# I2 {* Prints out the comments found in a .java file.
' k1 M  l2 G% a7 e2 s; J/ q$ y*/
4 r+ S' t. y6 @7 X5 h. k: s; p' Gimport java.util.regex.*;
3 ~2 d7 |1 O7 F% f" aimport java.io.*;
  j) v0 c- d2 J; U* ~import java.nio.*;
$ N, I6 ?1 b7 b+ D1 ]( ximport java.nio.charset.*;
import java.nio.channels.*;

; N9 }7 w3 A& A" F0 wpublic class CharBufferExample {
$ c+ ~0 U% E% z8 {: `1 U1 J- f* Epublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

4 g; j; h" @& D/ G5 ]// Get a Channel for the source file
File f = new File("Replacement.java");
, S' Q( g2 G: B3 |1 QFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
& {. C; Y# m9 w
" B9 e$ L- D! O* Y, F. I  u; v// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
0 q# k, U* g7 b; B! e) K
// Run some matches
Matcher m = p.matcher(cb);
! Z& ?+ X+ D# I) v$ Q5 K8 ~9 _while (m.find())
8 b( {4 l2 N2 ]9 d4 S. OSystem.out.println("Found comment: "+m.group());
}
}
9 @1 |% J  X6 E1 C
5 X: T5 B) _. j* G结论
! c% f& o0 v5 B7 y, E现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
6 E3 B( m' M! H3 ?1 r* g
JDK1.4之正規表示式
- b+ T* H' ?' R5 n( z$ o9 x: {' {" {written by william chen(06/19/2002)

--------------------------------------------------------------------------------
! V& u2 a7 k2 w; ]
什麼是正規表示式呢(Reqular Expressions)
8 [: ?8 @8 r% W2 T
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
5 r. D; Z2 U( p& D' c
. |# `" O2 l: J因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
& v& I3 q, m: I" U
+ R; T# B  C' p. N9 Y2 N$ S; C所以發展出一種特殊的命令叫做正規表示式
. k, m" x, R$ K5 t* q
- X+ ^. P2 M5 f% d& _7 P1 ]我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
$ K9 \" G2 e: J
) \' |) l4 I& _2 ]若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

8 A3 u" E/ W% t3 ^"." 代表任何字元
% d) x. z' R9 o7 j6 Y% r9 [
, W- t' N( l$ X- {- d正規式 原字串 符合之字串
; ?1 h) n) I, R; S3 d7 e. ab a
.. abc ab

/ b, k( L. K9 R. g+ a7 l* z"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
+ ab ab
* abc abc

' E- X% g  p4 ?4 [7 q"( )"群組

正規式 原字串 符合之字串
(ab)* aabab abab
* _/ S/ }: Q8 M# z" h! S% `
* f$ g- M. e$ }% x4 K: L; c字元類
' F* P* {( C+ w( A  k
) w$ d" e4 [; N9 g4 p7 N' h( X) G正規式 原字串 符合之字串
- J& Y& d, J) i$ \+ v% @[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
0 g/ `  E' z+ u* A+ }- Q[a-d]* abcdefgh abab
6 t6 l- Q1 [+ Z3 c) t/ x' P, k1 u% a1 W
- N. _/ E! \$ ~; _/ Y$ W1 ]( B
5 W8 A5 L3 k! j+ ]5 y3 B0 ]6 R8 F簡式
( R6 {% G1 L' u5 [
( w& h5 ?0 ?6 ~; W/ _; n. C6 _\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
: c- L# J7 P" }# c" p6 l\s 等於 [ \t\n\x0B\f\r] 空白字元
7 i# k% U( m  S* [7 S) c\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
8 Z1 k% O4 p; F% i! W% X\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾
; N1 H/ l6 S0 k5 \
^ 表示每行的開頭
% z- C; a! w* u  p6 m  l9 x. T$ 表示每行的結尾

5 ~" _: K* T0 Z--------------------------------------------------------------------------------
- s6 P, ~8 D* }2 v7 n, w1 Y2 s
: G6 _, T3 e: }  J$ N正規表示式 java.util.regex 相關的類別
6 X/ a" V( K* ?  ?0 O; H, c$ L
6 `# `: @3 J4 T! sPattern—正規表示式的類別
& S8 q$ f" @- [% u0 J% TMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

4 e9 w7 y% k: t# r5 F" Q7 z範例1: 將字串中所有符合"<"的字元取代成"lt;"
" \2 d1 J5 C/ i9 l
" T* _$ c4 H6 Z0 @& d' _7 Nimport java.io.*;
& ?7 {/ g# d/ S+ p; Q; timport java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
1 _0 U* [: T$ s7 U6 p% ^// BufferedReader lets us read line-by-line
( C  b6 o; G. \- L9 u2 ?Reader r = new InputStreamReader( System.in );
4 T8 i) h& [* }# T: p: mBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
. P% U/ |9 P4 [4 @' d9 A( _' uString line = br.readLine();
- s- m6 Z! V) Y+ Q6 ^// Null line means input is exhausted
if (line==null)
& \$ g  \$ c/ }" s* e  e8 |break;
Matcher a = pattern.matcher(line);
1 l% j5 U8 C/ B5 w# A! I$ x( y2 z4 Owhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
: N' h( ^8 X) e" l: b}
' @& ]5 A9 t( H$ lSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
9 s3 E' W3 u4 |6 T: y}
( Q. _# u( e6 m9 o8 J}catch(Exception ex){ex.printStackTrace();};
}

: H: B0 N* A* H  z  Z8 z範例2:
/ J. z% h! M/ z1 X  h' ^
import java.io.*;
6 l- F; U, y, d1 M: y3 @2 r% bimport java.util.regex.*;
3 A- {& V( v4 a/ ]* I/**
& p- \( p- K9 k. L; Q4 p* 類似StringTokenizer的功能
) ]- ?7 C0 T( y$ |* 將字串以","分隔然後比對哪個token最長
5 j" Y. v& m0 e: M5 E/ V7 U1 x*/
) F3 K8 T' n" r- @7 N0 _" xpublic static void search01(){
7 R4 c' f8 U6 F, M0 C" M// BufferedReader lets us read line-by-line
" {% l+ x) n$ r5 t9 M' mReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
' e* L  T% M2 a3 f2 Ftry{
5 r# N* U- @1 `while (true) {
# O" D7 ^; j" J) o  @$ ]String line = br.readLine();
String words[] = pattern.split(line);
8 o) W$ ?  Q* |9 T// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
& B6 T% i7 L: K- N5 Z$ L7 d! Aint longest=-1;
& C* Q2 a$ v) s, ?; i9 nint longestLength=0;
2 D( S1 O8 n2 o1 F3 X7 Cfor (int i=0; iSystem.out.println("分段:" + words );
0 d# z" h$ p* }5 wif (words.length() > longestLength) {
longest = i;
8 f! q- {. u. ]3 B" P! l5 }/ H% YlongestLength = words.length();
% w$ f% x2 ]+ y}
}
System.out.println( "長度最長為:" + words[longest] );
9 w% `+ m9 ~. Q}
}catch(Exception ex){ex.printStackTrace();};
}

4 s  V& c0 |3 S& `; g) y--------------------------------------------------------------------------------
2 p' I8 F+ a0 |1 Y/ k# ]
其他的正規語法

/ u9 b9 o: }' _7 l( [, X" m: ?+ U/^\s* # 忽略每行開始的空白字元
# [+ c5 G' v& c$ N. k2 h(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水