关于正则表达式---ZT

Longe

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

1 E7 d' G- B' ?$ Q支持多种平台


; W5 G9 {% w% D2 R1 q正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
! \* Y' z: V  w& G" l( ^6 I' |
3 ]6 ^, a6 C" h' m- [: u正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

* Q8 Z  S# k+ q4 {% O8 a许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
$ o! }+ s" z4 n+ C6 ]2 Z+ Q
5 y( T2 W0 J$ Z# W' B比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

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

第二部分：
5 l3 \# `0 P8 S) f. M# S8 f----------------------
  b6 |( P6 o* U2 Q% a/ ^! S1 k& `* p5 |字符匹配
8 V1 u  p9 `& a  q
8 t" g* \$ C  |7 a! B# i) x: A正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

' X0 a- ?0 M0 J5 T每一个表达式都包含需要查找的指令，如表A所示。
8 E: N. H5 P3 B$ q% N! ^: J
Table A: Character-matching regular expressions
, l1 K- O+ M2 ]# ]格式说明：
---------------
- T9 M  b/ L7 C- t2 W8 m0 S操作：
解释：
例子：
1 Y0 `+ D0 |+ S( t4 U0 V% a3 z2 {结果：
----------------
.
8 y1 s2 s; K% Z: \+ uMatch any one character
8 N, L, z2 q% Z, O8 K, h( l* Q0 e/ igrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
% Y/ Q4 {! {' n: ZMatch any one character listed between the brackets
* A5 ?; F" K8 g; g; vgrep [cng]ord sample.txt
1 ]# P" o% s: v" f! \! _Will match only “cord”, “nord”, and “gord”
6 y4 p4 J1 }9 @( X9 S  |6 d, Y" G---------------------
. s( g0 U0 `4 j% a[^ ]
Match any one character not listed between the brackets
# ?% Z4 _3 B/ d2 B3 |3 J9 d$ i  `
. Y0 S; [# p4 Q/ a  w. Dgrep [^cn]ord sample.txt
; R3 R& j, D6 B1 K% g) QWill match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
: Q2 K9 x- H0 n: K1 h
5 P9 C: m$ }& X1 H& ]$ }grep [^0-9]ord sample.txt
+ o" z, p" t6 H5 p$ ?9 s( B9 XWill match “Aord”, “aord”, etc. but not “2ord”, etc.

& C: a1 t2 w1 h; d! o1 k重复操作符
2 U8 n* w  ]; d( S2 U6 ~重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

4 @) ]4 D# @- c! v/ A0 M7 YTable B: Regular expression repetition operators
4 K9 V( Q' B' }/ T格式说明：
: V: N' y+ C. S, R) Q9 v. R0 E---------------
  G5 N" y. f- t0 u1 C8 R' e, \操作：
1 j' ~& l* T6 M. M3 R) B, [解释：
$ u0 A! g5 @/ a) k& ]例子：
结果：
----------------
) C% w9 y4 D/ E: f. z) c$ b?
8 D" o5 L  J7 x% OMatch any character one time, if it exists
7 M' R5 P. c8 J6 G  vegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
3 j, ^9 O/ z. O/ [------------------
( w' s" ?( o" }% Q*
8 I7 T& s' f" f) ^Match declared element multiple times, if it exists
8 y) _) P' N1 {2 p. `1 v& d- `3 }egrep “n.*rd” sample.txt
5 T. P3 F$ B! K8 `# n! f7 ]Will match “nerd”, “nrd”, “neard”, etc.
-------------------
! H* v8 t& J2 B$ n8 n  u$ V+
Match declared element one or more times
$ N+ K2 e% X; \7 E5 R8 _3 z) ?egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
Match declared element exactly n times
$ ]  e% E$ N- tegrep “[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
3 Q  i; G. Q. q3 c5 Y& ]- segrep “.{2,}erd” sample.txt
  q5 f( k+ e' s7 B' M* G$ S* [) mWill match “cherd” and “buzzerd”, but not “nerd”
" l$ _- ?( m2 v) X------------------------
1 f. O. J3 T* |2 t# n& j{n,N}
Match declared element at least n times, but not more than N times
" P/ l5 x0 A8 {) o. K" n% Yegrep “n[e]{1,2}rd” sample.txt
7 i1 \' [) l' z* T/ S) _1 k9 q% bWill match “nerd” and “neerd”

第三部分：
7 O3 I8 s5 G0 S----------------
# s, @: ]  L+ V# p锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/

1 T" c' z, }4 y3 z" P
# l" a1 C4 E! J: ?Table C: Regular expression anchors
, s1 N3 F- n. V" g-------------
操作
解释
& H$ ~+ {, ?) h% C/ M! P" B例子
0 Q5 x# e) a7 ~, y+ X' M结果
$ {* `% J1 o9 z2 k$ j% B---------------
^
Match at the beginning of a line
s/^/blah /
2 x$ u  ~4 d7 q. D5 X% Z! P( n2 GInserts “blah “ at the beginning of the line
---------------
9 v0 |, M/ R$ L: i( ]9 |$
Match at the end of a line
1 `8 ]# r' y5 Y2 us/$/ blah/
Inserts “ blah” at the end of the line
---------------
9 X6 @9 \9 C% ?0 o# y" T) R, p/ V' Z\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

5 u4 n0 A- K- W8 h+ F) Y' d9 J- N4 Legrep “\Matches “blahfield”, etc.
' F" o! Q* }! Q) x- ?' v( Q------------------
" D$ L7 x/ ]. X$ ?% p$ d\>
Match at the end of a word
: o+ `: ^3 Q2 Q! r3 Ys/\>/blah/
Inserts “blah” at the end of the word
+ y/ }; ?5 d$ F0 F2 J
1 E2 J; n# q4 @" k* cegrep “\>blah” sample.txt
Matches “soupblah”, etc.
+ {" W; }0 R: K9 d' j. e+ H# h---------------
" {1 B" o' P  o\b
Match at the beginning or end of a word
5 d% W' K% f! o( M" a' Kegrep “\bblah” sample.txt
2 C/ _; E- J$ w2 w( v/ ]Matches “blahcake” and “countblah”
-----------------
\B
: l0 r2 B3 b$ G% T0 HMatch in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.

间隔

) ~( F& n9 H6 ~! f- e4 w: fRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
6 z' k8 n! U; T9 N- f1 L& \6 ~
egrep “(n|m)erd” sample.txt
( R* b# b- G; n7 D) m
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
0 G% e; r7 B" p4 w
1 S* M; ]% s: H+ Uegrep “[nm]erd” sample.txt
* P9 v9 ?- \% b" J: E+ I
) P5 H  k" H$ E! T1 V当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
- e0 f1 o2 j* j) [) q  w
第四部分：
----------------
( y+ h: A, ~) \! u. v/ D一些保留字符
4 x% m# M* f/ v' N1 ARes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
& R" A: N* _% X# |7 r$ F
^ (carat)
. (period)
" U6 p4 F, k  h% b% [[ (left bracket}
2 d" a0 ~5 }9 ^5 u; a7 d$ (dollar sign)
( (left parenthesis)
: G. w5 ]$ w3 E! C5 c, z$ R) (right parenthesis)
| (pipe)
; }3 ?0 ]( M0 B* (asterisk)
3 c7 Q; P7 j; `+ v+ (plus symbol)
, p2 Y3 B+ L/ l3 ?  e% F" ^/ g? (question mark)
{ (left curly bracket, or left brace)
1 d' W1 Q* T. i; ^: Z\ backslash
: t) f1 f5 G" x7 b一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
0 q, {7 t1 X+ D
; z* o* d7 ~4 Beregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

, N) o' q. f" f/ Y6 \你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
0 V" M* Y4 N1 l1 F; ^% G在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
7 S, M/ i6 i) k
另外一篇文章
$ h# C( A2 h  m% \6 u----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法

! Q" \) J6 p  c$ g/ V3 R下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
0 }) a/ [' E# I, |  k: b
; W3 |+ j/ {* J1 @& g4 v( @/ Y: Q, _Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
0 I, T% }+ E  B
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
3 {' V+ ^6 W- w
& e! u: z. b9 f& Q2 e  y用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
) E6 C6 l( c) h' k
6 {1 w1 ^2 w2 b/ J% H% o1 @: zsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
! m! s. i0 J+ H" o8 X+ d/ K
/*
- Q4 s) ]/ ]% F* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

public class Splitter {
public static void main(String[] args) throws Exception {
4 I, N7 v# o& G# n6 b/ W" k9 b& c# s// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
3 v, ^  Y6 ]3 _// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
/ c. g. a/ e9 {& k  ~3 E1 z7 n}
}

% X/ a, p; \% u! \3 V8 C& J4 r2 bMatcher类
, G3 p( D$ i7 Y' i! z
7 W( x" R6 r( dMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
9 X, j  h/ \( ^7 T' b
9 S) Y+ ~6 t1 p' zmatches方法试图根据此模式，对整个输入序列进行匹配。
, r& F0 y9 ~: ulookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
2 w. G+ n' n4 G- D( A4 Ifind方法将扫描输入序列，寻找下一个与模式匹配的地方。

, ~' }* S# H4 w, {) d5 X+ D这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

- f" A- e! g, N% \' y% Y这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
& C- L9 _  @+ e- t% }' B
0 c2 a4 l" e' o6 [/ \6 c* MappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
$ M3 o% ?7 k3 H4 B; @5 g
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
9 L; t* C3 N9 ?6 w
CharSequence接口

+ j7 z  x: v6 k, z0 SCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
" d# p$ k) ^) A7 u% d0 X/ b% _, q3 s
. F$ r: Z2 a8 Y  f2 |- Z2 @* @. f+ ARegex情景范例

2 H4 m+ m; I; L+ U以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
0 O: ^, f0 ?3 {9 c; o* a( i5 X8 y
1 S. V3 {* u$ k简单的单词替换
8 j6 Q% v0 i( y: d! z" P. b1 ]; k
/*
( C( H' K1 j8 y: V! H- e* This code writes "One dog, two dogs in the yard."
$ j& R/ i) ]; [' ?% v$ x/ Q0 W* to the standard-output stream:
, R4 L6 g2 F. |/ p* ?% I: e*/
! u# \  |- r- h. cimport java.util.regex.*;

public class Replacement {
public static void main(String[] args)
       throws Exception {
. I* u& G; f; f( q// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
) Y2 s1 A8 e% h' h( ]9 o     " two cats in the yard");
. ]0 X0 J  j3 m6 Z% N/ \9 e/ s' NStringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
& A8 z9 O7 Z  Oresult = m.find();
}
- e) O7 T" {+ t5 J  x// Add the last segment of input to
// the new String
m.appendTail(sb);
( `  z; f8 J( n, [System.out.println(sb.toString());
% A3 J; W/ m" m6 {9 g}
) }7 w' ^! a0 U( Y7 m7 b}
% N8 p$ W7 d8 \
电子邮件确认

2 s6 x3 O) |$ m6 g* P以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
# z2 f9 `) X0 w. i* j* Checks for invalid characters
* in email addresses
*/
: r$ b1 L. w; e$ u# H! H* w: u/ h+ Z7 Mpublic class EmailValidation {
public static void main(String[] args)
           throws Exception {
  {+ V# c" X' R( N3 o+ w; u3 t           
6 H! w1 m# J" yString input = "@sun.com";
. L( n: s2 R( N( P( X" Y//Checks for email addresses starting with
2 P, H+ `. E" d' E//inappropriate symbols like dots or @ signs.
6 U4 k" E: r4 U- vPattern p = Pattern.compile("^\\.|^\\@");
# g% y0 s: b: u* G7 c- UMatcher m = p.matcher(input);
% n% E: q7 i7 gif (m.find())
System.err.println("Email addresses don't start" +
7 v  B  t: y; N! e/ ]         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
: P3 M# X9 q  p/ ~m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
2 I  d- i/ H% x: s   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
8 R! b& i5 {$ E, \/ mm = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
4 u  Z0 w, h5 k+ j}

// Add the last segment of input to the new String
m.appendTail(sb);
- x6 I7 t9 J" R
" r/ [5 e# {: Vinput = sb.toString();

8 f; i; n7 D' ~1 B% v0 Z0 N! mif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
}
; O; b% y2 M( \5 N) _" a
从文件中删除控制字符
. b1 m. K9 D6 M/ q* s' P) A
, u) K# i" \* g5 r. L/* This class removes control characters from a named
* file.
*/
: Q; i* |0 I# cimport java.util.regex.*;
) p- Z7 J) n+ Yimport java.io.*;

public class Control {
public static void main(String[] args)
* ~# t* v8 @% K: ^: p           throws Exception {
- V: X7 l/ B0 V: O9 z4 n           
9 y7 [$ q6 d1 l, V& G1 M6 {  t//Create a file object with the file name
//in the argument:
" W. M/ K" q' d# [. AFile fin = new File("fileName1");
File fout = new File("fileName2");
: P8 @, N* B* m- s//Open and input and output stream
# M  \2 w& I" R# E5 @FileInputStream fis =
) x- V7 M7 M  ~7 E       new FileInputStream(fin);
+ \: X7 x' n1 w' a' S" rFileOutputStream fos =
" @+ }# R+ B, x% ]# ~       new FileOutputStream(fout);

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

4 p$ M( S2 Q' L0 V1 E// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
6 ?# m6 l1 F6 r, T+ Vwhile((aLine = in.readLine()) != null) {
& u7 H& R0 y8 ?1 Lm.reset(aLine);
//Replaces control characters with an empty
6 X7 L" j0 w0 q! C: b: X. u//string.
9 j! m; s$ y& BString result = m.replaceAll("");
out.write(result);
8 a8 G8 H/ v2 g1 }' Qout.newLine();
4 @% ~" ~, {, a}
in.close();
out.close();
}
' i" D( o+ t! ]# k}
1 L6 n* {6 p; C( a4 p: [+ i
文件查找

- e' _+ G2 O1 ?, y/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
3 k' T7 B. p9 [# `% F4 ?( bimport java.nio.charset.*;
import java.nio.channels.*;
5 b; r3 R; T+ T3 m" {
public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
4 ]1 A8 @+ L/ x. R! |/ fPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
, B" a6 P: h4 m; L
: N$ F  E; O# E9 }2 O4 ?// Get a Channel for the source file
3 Y5 |+ {: N) H. ^File f = new File("Replacement.java");
2 T# C" X' g1 y3 i8 JFileInputStream fis = new FileInputStream(f);
, G. u: w- Y, `3 B9 r) y4 yFileChannel fc = fis.getChannel();
. v: X$ T) u9 ]
// Get a CharBuffer from the source file
ByteBuffer bb =
2 P1 k( N8 q; ^( d6 w. F6 Vfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
$ t8 b/ d) \1 P# s9 X% KCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

) N. ?2 a8 L/ n5 [// Run some matches
Matcher m = p.matcher(cb);
1 D) i$ a3 V  t  t5 l, ^9 @while (m.find())
System.out.println("Found comment: "+m.group());
. X4 h0 b' _' X6 f}
}

. T9 @+ A- J& E+ p% w. L结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
. G$ Q" g) x; x0 d
JDK1.4之正規表示式
/ B" W5 ?. [- i% Jwritten by william chen(06/19/2002)

9 B1 W( Y( u$ w% \1 P" }--------------------------------------------------------------------------------
* @" }9 f0 ~/ f( g- W
- \, n+ \5 F- a! D/ ]. ?+ L什麼是正規表示式呢(Reqular Expressions)
* f1 o7 N# j3 H# Z
" E- R: o; u: X就是針對檔案、字串，透過一種很特別的表示式來作search與replace
3 r% ~- O2 [/ O/ u9 b* ]
7 p# `7 {# S- r因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
; s% s) T, D2 h$ B! z& _, N
: t  f) T6 T' n. u3 T- I所以發展出一種特殊的命令叫做正規表示式
/ h( G  S+ P/ g$ r; ~" b) J; J
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
  D) C& g, a1 v# U- x
剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

"." 代表任何字元
! x5 p4 ]$ P8 P1 J! I
正規式 原字串 符合之字串
. ab a
" T8 j! x: Z1 j$ p. _# N.. abc ab
9 {5 h& c, ~! J4 v
"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
- i+ s5 g0 i" }& u' d3 ~+ a7 ]. F
正規式 原字串 符合之字串
3 R- _; i: a. t! h! a4 x* M+ ab ab
% a4 M* u: `  A& ]1 z+ ~' p* abc abc
* w. S5 o& V6 }. |- @% Y" q
"( )"群組
! \9 {! i# T; n  I' h7 g$ \6 s
正規式 原字串 符合之字串
, {. E& K8 @9 N) E2 u1 h(ab)* aabab abab

' C# Z* [" t/ i6 ^字元類

1 f9 [2 Q3 F9 A5 X& |正規式 原字串 符合之字串
! e# G' Z5 ]& T- T9 k[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab


2 T8 @; h+ |! |& j簡式

\d 等於 [0-9] 數字
) J/ z9 k3 q# @4 Y8 e\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
4 \! ~: U7 H  j% l+ i\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
( h* _. D: Z6 K1 m8 _
每一行的開頭或結尾
1 `$ {. g+ i1 s' M5 C5 |# D3 H/ T9 j
^ 表示每行的開頭
$ 表示每行的結尾

+ h# B$ X7 F5 a8 b, E--------------------------------------------------------------------------------

. r9 t8 a" w# M! A& N9 Z+ O% `, k正規表示式 java.util.regex 相關的類別

6 U; C2 @: t) A" B0 e) P1 V: ^$ g$ yPattern—正規表示式的類別
Matcher—經過正規化的結果
1 N- W) b- Y. W$ |PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
1 A6 Z# A! u; d: i
3 A% g3 ~3 [! |0 B範例1: 將字串中所有符合"<"的字元取代成"lt;"
- g, m/ i( A2 N, H9 C
+ M& i0 e) a8 F; h, m- Eimport java.io.*;
  E0 q( g* J7 j1 }: q/ Simport java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
3 G, c/ m0 L9 M1 t0 k5 o! g*/
public static void replace01(){
// BufferedReader lets us read line-by-line
4 m3 J1 H6 V/ V; g* b# MReader r = new InputStreamReader( System.in );
  v, [/ O" c2 T/ f& ]BufferedReader br = new BufferedReader( r );
' p3 A" `; z6 p  `Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
8 V/ k+ O+ v$ w1 \String line = br.readLine();
// Null line means input is exhausted
if (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
! u1 r" E6 b' I7 @7 E, I. X7 P6 pSystem.out.println("搜尋到的字元是" + a.group());
$ d% [7 |" d3 f}
; d! A0 Y: \( N& j; @! l( d/ LSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
- N  ~, k: Q9 R: E9 f}catch(Exception ex){ex.printStackTrace();};
! _. B! f% C* T" ]8 L}

範例2:
# _, @. a$ Y/ Q) }$ M! R* J
' H- I! S# l7 gimport java.io.*;
import java.util.regex.*;
2 x# J8 c  v. T$ A/ x: \/**
  K- j9 {/ X8 C/ S7 G# e" O6 s* 類似StringTokenizer的功能
" ^+ Y9 a% E6 S! Z$ m' P" r* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
1 d+ h, `3 Z4 R// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
/ z6 E. F; y6 }1 Y, w0 O- UPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
- U6 F0 M  [, ]! p% T, Ptry{
  L, l: b% c$ J" s( k; uwhile (true) {
1 V4 f2 {1 x$ p; O0 qString line = br.readLine();
String words[] = pattern.split(line);
: l# n* Z* O2 l6 j' d// Null line means input is exhausted
8 S- U" `' ~& y3 J7 [2 g+ Z! E" xif (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 );
if (words.length() > longestLength) {
# }; S4 M5 R. [# D" tlongest = i;
longestLength = words.length();
}
}
System.out.println( "長度最長為:" + words[longest] );
}
# j5 l* Q( k; \* W, X}catch(Exception ex){ex.printStackTrace();};
& m5 Z  k1 z% T1 f}
5 }3 X! T5 u$ \+ c7 H
& t8 V( v& A0 T: q# ^--------------------------------------------------------------------------------
4 _" Z, D7 s# a: b/ ^8 _
0 g- H4 s: |1 ~6 F$ ^/ V+ c! V/ Q1 Z其他的正規語法

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

一叶

一头雾水