关于正则表达式---ZT

Longe

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

支持多种平台
& J9 S9 z4 F/ h4 ^

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

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
! R+ q! S) K1 T: u# v8 o: f
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

  ^, r1 Q, M! K4 x比你想象的还要普通
8 J- ?. M: A9 q* `% V9 v随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
  s( F# S4 w- E
正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
+ B) A! i' F' \" q  M. E( k5 ~
第二部分：
----------------------
" H! g( O4 r5 e: r5 G. G# q字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
: P/ P# N+ d% d0 V0 l
; h5 y- Y+ z" ]/ N( T每一个表达式都包含需要查找的指令，如表A所示。
: i& N" O) l4 b* [$ x3 D6 C
" f* V& I) P% H6 B' C- \0 rTable A: Character-matching regular expressions
格式说明：
---------------
操作：
解释：
例子：
+ ^$ J+ l. d8 H, E$ Z- T结果：
----------------
! p$ U" p3 i, V. h: X4 B4 R3 Y.
( T0 K+ L7 \: l' B5 aMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
1 d+ V; A  a% K0 f  \. R* @-----------------
[ ]
7 Y. t1 J. _$ x* N8 FMatch any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
[^ ]
Match any one character not listed between the brackets
% S( \. C1 w# y2 |4 U5 C
5 e4 h2 ]9 B$ i! Ggrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
0 p& U* E" C5 D2 tWill match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
8 h0 S/ l8 F5 o: ], C重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
( i) Q6 o- e, F+ i格式说明：
---------------
操作：
解释：
例子：
/ e: L( `2 Y( p. [结果：
----------------
3 w% o6 e2 x+ l/ \+ D9 N?
Match any character one time, if it exists
* o5 V- \" s1 L: |0 @+ W' `" Uegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
- m' Z8 ?! D" [- J+ m, n------------------
*
Match declared element multiple times, if it exists
( u, h' ^7 K; ~3 H8 ?8 Legrep “n.*rd” sample.txt
9 f( \: ]6 Z; S2 X" m7 q$ oWill match “nerd”, “nrd”, “neard”, etc.
-------------------
3 ]- y( @2 c; [+
0 k) A$ S1 Q9 a4 K9 I9 Y  z% eMatch declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
9 `, B- n- J# `# L7 L2 t! s% B--------------------
{n}
8 J- f- U' l* \2 }; _Match declared element exactly n times
+ n) P0 t3 J' L1 f5 h" i! Qegrep “[a-z]{2}erd” sample.txt
! I* i7 y& @! y8 s; W6 r6 k. L6 c# `Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
3 G& }; A  X9 n- A) e, n------------------------
5 W7 {8 P( d  E: p8 Z- Z{n,}
! n+ }4 _1 d4 D( fMatch declared element at least n times
, f- m( t  X# cegrep “.{2,}erd” sample.txt
9 Q' ?* q; E$ @0 O3 [8 E! ?3 TWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
0 F' k9 T  P9 ~- S8 NMatch declared element at least n times, but not more than N times
+ Q( l- @  F# k/ k2 q+ g  ~egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
. q$ K. T7 X8 V2 E$ T
第三部分：
----------------
$ o* n9 Z6 `) o  z3 Q锚
5 E  s0 f' L7 X: {, C锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/

* ^% b3 E+ I& U8 |4 q) f
( D- a; a! n2 m) l. bTable C: Regular expression anchors
-------------
0 h. }( ^$ A2 N0 P操作
+ S# \' [% H: W6 J$ d解释
3 a2 F$ L7 F5 ~+ z# ^7 d7 i例子
: ?1 j3 K3 a9 e结果
---------------
^
; f" c% `$ K# g5 i; ~) KMatch at the beginning of a line
s/^/blah /
  u) {9 y$ n, c: w1 k& ]# `( OInserts “blah “ at the beginning of the line
4 s3 L3 X+ ]: S" x9 n---------------
  T. N" E1 z2 `0 g+ _7 U( X9 K! D$
Match at the end of a line
( D# P0 S7 z8 b$ H$ Cs/$/ blah/
& `: P, N" x* L9 U, K) `! ?/ IInserts “ blah” at the end of the line
---------------
+ _. X3 V' i; y8 T3 F  M- u$ w; Q3 P\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
( ^4 T. J. z0 H3 S9 }& {: k
' G% i; ~0 `3 N& segrep “\Matches “blahfield”, etc.
------------------
3 S  V  U6 ~9 }, V\>
8 w/ [7 Y- d% o: a9 @Match at the end of a word
& P6 T$ ~6 a2 R9 ~  @s/\>/blah/
; E: w  E, d. E4 rInserts “blah” at the end of the word

5 q) O$ I5 ^3 A! q% T" }2 Aegrep “\>blah” sample.txt
$ Q5 x) x9 Y4 Z9 O7 m. x: S0 NMatches “soupblah”, etc.
---------------
+ ?4 u/ |$ y: d# [# C\b
Match at the beginning or end of a word
: G; S& T; C* V+ H: legrep “\bblah” sample.txt
/ w% r$ J$ p. X9 d% M* L9 PMatches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.
; V6 Y3 g! L/ U  O1 S3 \1 }
* K' U) l' b/ o间隔
6 o2 J/ P- w. s0 P: ^* }
4 g! Q7 B% I- U7 tRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
  b& j2 h8 E5 z0 T+ r, O0 N
9 l& n) F* b" W1 H" eegrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
( _4 F8 `+ B, K& C* K
2 s7 u! r$ R' ]. H/ qegrep “[nm]erd” sample.txt

8 z/ u3 D. d6 [& C当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
% m: ^7 b2 r" O0 G' k) A8 I; p1 I
第四部分：
3 S* T8 G2 p( Y! f% F----------------
" T, _6 [5 K" e5 O3 n一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
% M3 W2 x# v* a
^ (carat)
+ @0 U8 v. C5 P. [! n4 R. (period)
[ (left bracket}
# `' f& d# q4 k' R8 G$ (dollar sign)
; |% m6 U) i3 s, R1 |+ c( (left parenthesis)
( H9 ?8 _+ h# y* ?- Y, B( z) (right parenthesis)
| (pipe)
9 B! I& H! f5 W5 p( b* (asterisk)
7 p; ^! P* ?# F# F) f! A+ (plus symbol)
, M) E) o8 q, X* Z+ d: L+ l1 y: C  I) }? (question mark)
{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
6 H7 v, F5 X, D# Z7 ]4 O
4 [/ I3 j4 W: O" G$ R8 Q7 F你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
9 i, W+ _2 W* s. f3 N! F
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
) E4 r4 B3 U: K+ A. J( w5 w
' A( G7 x/ Q4 f另外一篇文章
8 w; D. ~" p$ i. ]7 `! E----------------------------------------
8 D, U5 @0 ^. o( {6 k* |正则表达式和Java编程语言
0 P0 V% b) H% N- S: S) n( u. z% \" j-----------------------------------------
类和方法

+ ~/ x8 e6 v3 R4 Z" q下面的类根据正则表达式指定的模式，与字符序列进行匹配。
4 n- U2 |! s% m) k4 X, T
" W! F/ T2 T) m8 ]3 V2 v4 LPattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
. c6 ?7 m  O# E2 B* e
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
, w% w  r( [0 u  c
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

3 K4 S5 c7 i6 K$ A3 p- c% L; Osplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
4 T2 N0 Z( N7 q4 C5 O/ F
/*
2 ^. V4 M: n; Y+ e# H1 O) ?' d1 D4 b* 用split对以逗号和/或空格分隔的输入字符串进行切分。
  B' A# T/ p$ U7 q- D*/
import java.util.regex.*;
- L- ^* L: j7 X: f
public class Splitter {
public static void main(String[] args) throws Exception {
4 k9 p9 O) O# y( S5 U! P$ x// Create a pattern to match breaks
% f0 d$ ^; i/ v; @- NPattern p = Pattern.compile("[,\\s]+");
6 X' R9 j, Y5 \+ ~" u7 T8 [: s# q9 M. ]// Split input with the pattern
String[] result =
' p( _& d! w, q   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
5 }) ]' q  {7 |5 f}
+ ~. M: [9 N& h8 S}

* @# v! c8 A$ i# f5 kMatcher类

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

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

5 M9 _3 _& C, }4 `4 }2 S# _matches方法试图根据此模式，对整个输入序列进行匹配。
( C  I- J$ n0 G  r  L, T/ y& n7 N  NlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
9 ~9 ?; F. i- _: xfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
6 k) Z( j2 R( q5 r2 h8 Y
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
. _* i1 B' o. E/ T5 B
. x2 z3 Q$ \) s7 H% I- JappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
  k3 j% K, s3 @7 e% \& e( y
CharSequence接口

- {) ?0 f/ x( h' Z4 Q9 T7 HCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
1 ]- g( |6 E2 f& D' J2 k
Regex情景范例

8 {0 M) I& z3 F% K0 D以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

0 d: J0 N' ]0 t* y( W% |, {简单的单词替换

/*
. G- ?% H: H2 u% V$ Z, J& i& Z* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
- j+ [3 O. v* w*/
import java.util.regex.*;

9 Y; Q, s8 ~1 f6 j5 R, ^) Bpublic class Replacement {
* `5 f7 e" `3 }% k, C1 v$ z7 Upublic static void main(String[] args)
4 {" x5 E( K1 N) {$ [       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
' k$ ^/ H# _; K" o% ~0 D3 G% v- \// Create a matcher with an input string
8 m) S- v/ U9 T3 J( N' xMatcher m = p.matcher("one cat," +
     " two cats in the yard");
; o3 U2 f2 O8 W! G' ?7 `: cStringBuffer sb = new StringBuffer();
1 ]/ [6 d0 L. Q; \0 w; M) fboolean result = m.find();
5 t6 q* r. R7 B* O3 X8 M// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
# v4 m2 Y0 N7 v0 x/ yresult = m.find();
$ d' I0 [: I: d7 Q4 I}
1 O% h  J$ [. e: s/ N// Add the last segment of input to
// the new String
) S3 C* u. B  U3 B$ B& Cm.appendTail(sb);
System.out.println(sb.toString());
}
% Q# K# l7 |+ m; Z* N" p$ I8 A}
9 w( S2 |' U' W: {* Q6 W" Y
电子邮件确认

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

/*
* Checks for invalid characters
* in email addresses
*/
  }4 D+ ]1 r$ n  N+ Apublic class EmailValidation {
6 Z( \6 [6 T3 \! wpublic static void main(String[] args)
           throws Exception {
           
6 M; q9 p8 O* A' C8 ~String input = "@sun.com";
' s% {" Z# a- U. X9 s//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
! i  p6 o& t2 E0 nPattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
3 L! Z2 n2 V! Z  z+ U- j/ `# o         " with dots or @ signs.");
//Checks for email addresses that start with
& L1 P$ _  s! i6 N- q7 {//www. and prints a message if it does.
1 j3 L0 F- p  l5 h* t/ wp = Pattern.compile("^www\\.");
m = p.matcher(input);
% n1 o! g4 e" ?2 nif (m.find()) {
$ k# m5 y4 k% ^4 kSystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
5 X4 H) B( o. y5 K* o8 |1 ?p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
/ J7 j, C3 ?' K4 O7 xm = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
, M6 q, y5 u% I# U# Y9 ]deletedIllegalChars = true;
m.appendReplacement(sb, "");
: G# ?7 S2 A5 {. i3 u+ Lresult = m.find();
9 G+ [. N, z/ O% o) ~$ j! D. n}

: o1 x* c( u2 _$ M4 W  F. g8 X// Add the last segment of input to the new String
2 l! q7 N2 S3 u' s, {m.appendTail(sb);

- K5 C8 q2 \& o5 z1 N% c* }input = sb.toString();
0 ~: Y0 p9 {% \" O& d+ v  a2 i
if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
+ a. `2 S8 t# `. |+ w* e7 I}
9 Z1 d- D" n! j: B}

从文件中删除控制字符
+ F  b# o  O5 C5 u% l9 {
/* This class removes control characters from a named
& y! i  {( ~% k* file.
*/
import java.util.regex.*;
6 ]! H  ^6 r+ aimport java.io.*;

public class Control {
8 ^# B# |0 Q# J$ q" k; N% dpublic static void main(String[] args)
. m; J9 [3 l2 ^0 e  J% v! V, q           throws Exception {
           
; p' D( }: |7 S" K# A+ i//Create a file object with the file name
, q( s* Z) H# R9 a, f6 Z, A6 [//in the argument:
8 u4 z2 _) o# x% i/ J3 RFile fin = new File("fileName1");
4 C. r4 X9 U* gFile fout = new File("fileName2");
//Open and input and output stream
# ^6 c) k, r& W1 M+ p8 s8 hFileInputStream fis =
/ n: L4 w4 t+ J. n) j       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);

! P) K6 q5 w9 i  A; a/ CBufferedReader in = new BufferedReader(
7 k+ i9 \$ w  d     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
; t; _# N0 |* C1 o- z. }: S, F     new OutputStreamWriter(fos));

$ P+ \+ l: R) h& n" G1 N/ j// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
& \" k: C/ l3 T! j9 HMatcher m = p.matcher("");
String aLine = null;
8 W' `: w4 A/ fwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
9 A! a' A" N* K  O; ~# HString result = m.replaceAll("");
$ [5 K# z& `3 i0 o; c5 b. Kout.write(result);
out.newLine();
}
in.close();
out.close();
4 s, H8 H$ }1 h% z! n# n* `}
  y: [  F; n  I' h; N, s4 Z}

文件查找

! L( b' ?, ^# ^% w' A6 j) z5 ^/*
* Prints out the comments found in a .java file.
3 x, f- U/ y9 [7 v% h! Z1 Z6 R*/
8 |& F- X- k" C7 vimport java.util.regex.*;
import java.io.*;
! S. o  ]( ?1 Gimport java.nio.*;
- D/ l& w+ Z) r) aimport java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
2 \" G7 |( j& Q* T$ g+ Fpublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
7 Y/ P! {! s. y% a3 KPattern.compile("//.*$", Pattern.MULTILINE);

6 w+ M8 `* N, Q// Get a Channel for the source file
$ E( Z8 w- I9 V7 B9 Y- ?File f = new File("Replacement.java");
, O# C3 n% D  q0 D4 HFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

4 b% |. o9 i5 v- D- a* @1 \5 T// Get a CharBuffer from the source file
ByteBuffer bb =
  Q& |/ z+ [4 U1 o) j8 B0 Dfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
) M1 C; w5 i$ S8 RCharsetDecoder cd = cs.newDecoder();
! Q% n$ e5 k" M8 u9 ICharBuffer cb = cd.decode(bb);

// Run some matches
) G: R8 y4 c0 v+ MMatcher m = p.matcher(cb);
while (m.find())
0 W& g  ^# ~. FSystem.out.println("Found comment: "+m.group());
}
}

: Y; K7 s5 H& A* q结论
8 q! n3 k2 F3 B现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
. _; l" w9 c4 B/ M) p
/ A" W1 H7 ~3 V9 Z9 JJDK1.4之正規表示式
- U6 W( F2 a( S3 q: \( a, B% I7 awritten by william chen(06/19/2002)
+ C5 j% \# p) Q. ]; M
  U, a) J" }. k0 S# ?--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)
6 ^& A( E, K2 C% i
就是針對檔案、字串，透過一種很特別的表示式來作search與replace

5 }/ N- n' k4 v: {& H- }/ Q因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

1 b2 r8 A9 Z5 V4 O0 P  T! j9 j所以發展出一種特殊的命令叫做正規表示式

+ h% \9 t$ n4 I/ i$ L$ U" Y5 U我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
0 s" [5 u. |' E& u% Y) S3 ~6 y
' Z3 Z6 U5 l- y2 v& h剛剛列出的一串符號" s/
" n/ @# Z- P% m9 i$ W. |適用於j2sdk1.4的正規語法

"." 代表任何字元
" v8 `- R. R! }, V: K' ^
正規式 原字串 符合之字串
. ab a
.. abc ab

"+" 代表一個或以個以上的字元
5 x0 s. B& Q2 y# h( P"*" 代表零個或是零個以上的字元
2 C( G2 p- X) J$ t( [5 [' K+ v
正規式 原字串 符合之字串
+ ab ab
0 k/ P5 e  F4 e% _( s' ?* abc abc
4 i* N, Q* K# Y3 x
9 b1 K: i4 g! m) T6 b1 G5 q"( )"群組
+ u( C: {! D1 R& Z
6 g7 o9 r/ x! Z( U正規式 原字串 符合之字串
(ab)* aabab abab
/ `& n0 u7 \$ H6 q
字元類

2 `$ {7 w9 \/ j+ S1 }* x8 K! V正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
/ U, b2 i/ H4 w# p; U6 E1 L[^a-d]* abe0 e0
. _7 }3 z3 E" ^  F4 J[a-d]* abcdefgh abab
5 e; w' K1 [/ J* ~' b$ R& S# m" E/ Z

簡式
0 L* I& N7 n/ I  }
\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
+ }0 Z+ A: q5 F\s 等於 [ \t\n\x0B\f\r] 空白字元
3 d, u1 D& g' |% h; d\S 等於 [^ \t\n\x0B\f\r] 非空白字元
- }- r. m7 `4 i0 \\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

1 k3 c1 N+ h/ N6 s4 y5 I8 d! O^ 表示每行的開頭
4 a7 n; r7 m6 ^( n" g) h$ 表示每行的結尾
, ~) @2 ~6 E% _
6 }6 g& f% U: |0 g! y--------------------------------------------------------------------------------
# P3 A9 |; L% S* e9 A" m
正規表示式 java.util.regex 相關的類別
& k( T' f( T% t
Pattern—正規表示式的類別
! ^2 C' S  s3 I6 V9 RMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

* g  \* `7 J0 z4 F6 }! W; I範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
import java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
( i) @: }4 B) ^$ n6 ^* N1 y*/
public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
% U5 {; C- @5 uBufferedReader br = new BufferedReader( r );
- V; ]9 s, ^5 d5 DPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
7 u( m% i8 d+ i  D9 p. Y" Atry{
2 G# o9 o  I8 D. g8 Q" ?while (true) {
String line = br.readLine();
5 u- \  l0 g! u+ G, p4 L// Null line means input is exhausted
if (line==null)
break;
Matcher a = pattern.matcher(line);
, {- p; ?+ p" b2 ], pwhile(a.find()){
' E6 |% v- h! _4 I% h6 N* ASystem.out.println("搜尋到的字元是" + a.group());
5 V1 Y9 `" S3 V' c& Z}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
}

範例2:
* g8 l; n, ?$ D7 V! F
" q" P" A, C/ O+ aimport java.io.*;
7 o, a+ R2 |  v; V& dimport java.util.regex.*;
/**
* 類似StringTokenizer的功能
/ J; ~: H) q( J( y7 e* 將字串以","分隔然後比對哪個token最長
( _/ A6 m, U3 p" ^*/
7 z. ?1 h; M. {% F4 ?9 {public static void search01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
6 g& E4 ~3 L. d8 _/ W! h: EBufferedReader br = new BufferedReader( r );
) g( F0 a; s, p7 f, S2 H& f' ZPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
$ G3 T. b! X5 ]/ Y! qString line = br.readLine();
String words[] = pattern.split(line);
$ t  h+ i% J! j// Null line means input is exhausted
8 b& x1 j7 f; f' s# c' cif (line==null)
break;
, Z; r9 ~, B. Z/ n7 u& o1 E// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
4 x7 F8 ^% ]  L8 |( w) x8 K  Qif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
}
}
  J+ F$ u$ q. Z2 k4 ?System.out.println( "長度最長為:" + words[longest] );
! j8 V, G- ?9 ?2 I( e}
, k' ]0 }% {2 t( h# {+ A& C}catch(Exception ex){ex.printStackTrace();};
5 J4 i9 ~& u9 J4 |% a' M; E}
, Q" j$ O; g1 B5 z3 v. L( }
. p( O7 t+ A3 a: M8 r--------------------------------------------------------------------------------
5 I# J$ r7 f+ l' k5 u3 ?
  ?5 Z: `! r/ G/ w2 b. l# D3 X1 _其他的正規語法

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

一叶

一头雾水