关于正则表达式---ZT

Longe

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

0 l( d( t+ a6 T& k/ l. K$ l支持多种平台
7 T1 N5 g# o6 I
. U* J3 E# i% R: ?; J, c
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
; r7 @$ ]9 C& w& P8 I: }& a
  O. @" S4 |/ F& u# @正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

  g9 M; b5 y/ u. D9 [. @/ h% a许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

8 g& L: \2 j7 d2 `$ @; A+ m比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

$ U; s0 [# @; o7 @$ @, W/ c正则表达式101
! K# Z: a8 ~/ N) Q# i很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
----------------------
字符匹配
. p- z/ M1 K9 z
( B# W. q, A3 }  X, x$ [正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

3 t6 x9 Y/ v. y* p每一个表达式都包含需要查找的指令，如表A所示。
1 r/ h+ S4 K! R7 P
Table A: Character-matching regular expressions
格式说明：
---------------
2 Z/ y; X' A6 F2 Q; r. q  w5 D+ m& @) A操作：
+ ~1 m% J7 D6 M( H, y7 w解释：
例子：
结果：
----------------
7 ^& _8 p' |; z; N9 `7 x# n.
Match any one character
9 B4 i7 r& v* dgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
' [- V  @* A  \$ S7 z2 c" Z  ^1 j; S-----------------
[ ]
0 Y0 z( q2 T9 hMatch any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
[^ ]
& E3 N' E, v# v0 X# _6 ZMatch any one character not listed between the brackets

7 G2 l/ o% @: C6 Rgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

: p$ W. [/ p) ~' Vgrep [a-zA-Z]ord sample.txt
1 u" W3 d, D3 |% vWill match “aord”, “bord”, “Aord”, “Bord”, etc.

& U  [  ?) Y# ?( t) w; v' }grep [^0-9]ord sample.txt
' Z: D6 ~+ c1 U; Q* Z9 jWill match “Aord”, “aord”, etc. but not “2ord”, etc.

. r( }  b6 O; ~  q* d重复操作符
# |, x$ f. {4 q6 T' S! ^6 H' _重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
) q! _( B( V! e; W, G" H  V
Table B: Regular expression repetition operators
格式说明：
$ |4 L; A" ~+ m---------------
操作：
解释：
例子：
$ x+ e. T- q! [) i6 R结果：
/ v/ f4 \( v1 S: `9 r) a----------------
# ?5 s$ [2 G% m?
) q2 E; I  \, S6 b9 B2 a: |Match any character one time, if it exists
( I3 n" H& n0 E  Gegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
+ T: N3 Z  C0 d$ p: X6 ?! y------------------
* T- i8 ?* v4 d& j2 ^*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
2 ?3 }9 Y8 g+ l, o( B( f5 |-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
1 X# c* |* D: VWill match “nerd”, “nnerd”, etc., but not “erd”
$ Y! A" H- G  V1 a, ?( s. Q--------------------
$ e* i. y8 X% }8 A{n}
8 c8 ^2 F  o2 p9 mMatch declared element exactly n times
9 t( u# V! N- s1 X) Aegrep “[a-z]{2}erd” sample.txt
' F/ z+ _! v7 v! ~) JWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
+ N; e; ]1 W- i3 x. p+ a{n,}
3 W$ v( S2 E) I( L" t# U( PMatch declared element at least n times
) Y: z8 G& ^/ F. Y5 X7 yegrep “.{2,}erd” sample.txt
1 \) D6 D5 o0 O, w9 F* iWill match “cherd” and “buzzerd”, but not “nerd”
" U# n+ o. ]( C# S: z/ Q------------------------
. _9 z# L; m0 D0 e{n,N}
8 p& Z: e& r/ G" [. T+ V, WMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
0 @! R5 z6 `5 O! m4 z5 H1 E) U
第三部分：
8 m! M/ E- J  X& V) c----------------
/ u9 }6 [* Z1 @, y锚
1 a! G" U' N' Z5 E锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

' i, y# D. d* Ns/pattern_to_match/pattern_to_substitute/


) E8 w4 e2 o( n; ]1 R/ ITable C: Regular expression anchors
) G8 u; A: E1 v-------------
. N- M! D8 c- j# v: S操作
解释
例子
结果
. w. Q/ ]7 X& s/ m3 Q. o. [---------------
^
# Q9 l& V. L! ]3 u. O) I9 \: xMatch at the beginning of a line
, w0 ]' P+ ?; ds/^/blah /
Inserts “blah “ at the beginning of the line
- ^: Q$ r# z9 \6 d$ I/ Y3 `---------------
$
Match at the end of a line
s/$/ blah/
8 I) E4 f( v: x3 X+ I0 `+ _Inserts “ blah” at the end of the line
7 S, T7 f! w8 t6 f9 p---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
; ^; U/ b! f9 l. O' Y  x
! k5 g: h. r1 P( _* v- Yegrep “\Matches “blahfield”, etc.
------------------
. t0 E& t) ^* l0 l\>
6 H- s3 ?/ q' _, \2 V4 @6 LMatch at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word

$ r1 K) ^( ~& l+ F5 V: Kegrep “\>blah” sample.txt
Matches “soupblah”, etc.
9 O3 z- k7 @3 s" q7 K2 m& A# k- n---------------
* Y, f: N  p( Y! t% Y$ E\b
Match at the beginning or end of a word
+ E  @# z* o6 A$ T- F6 Degrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
: S" `; m8 \5 t7 u" y/ _\B
Match in the middle of a word
0 B9 ?, k/ V+ F4 W8 p% wegrep “\Bblah” sample.txt
2 j" B+ Y7 Q7 O4 n0 s( KMatches “sublahper”, etc.

; i6 L, u' L8 K/ l间隔

' k) s- g& s& u- |Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

egrep “(n|m)erd” sample.txt
$ c9 B  y( f8 c& S! q7 O
, I9 z' R: `$ m" R# ]( ?3 [间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt
! P9 k# V- P* O; i6 l: O
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
8 d- S3 N4 K$ g8 I7 V& j) p
: j0 I/ y; Q5 q* [  F# `6 l8 f第四部分：
----------------
5 X' [- r4 }/ S9 k& y% D* W& s一些保留字符
5 C$ [# R" c8 H! P: g% q5 Q' CRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

+ f! w  F) L- j- ^9 u1 E; ?^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
: A* j. u# g" l" h( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
# m: t; K8 A! f* _7 `2 O? (question mark)
- S+ h$ O0 N: [! ?3 P' V1 J2 b  b{ (left curly bracket, or left brace)
5 A  N9 O2 T+ N\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
+ b5 ~5 X, `# e3 _, Q
4 u& c7 Q1 q" y* I% ^& z9 Peregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

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

3 b( ]) \0 ~- K总结
# W% a) J, j) s- D, k+ x在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
. ^' l1 k; L" T0 M! [8 p! [
另外一篇文章
----------------------------------------
- u, w$ f: T6 {8 k- @0 G4 ^正则表达式和Java编程语言
% p" M& B: y. {4 W1 r" I8 u2 j: U-----------------------------------------
类和方法

下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类

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

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

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

split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
1 o8 p: m. a- f
/*
9 d8 a% D) |: @% J* 用split对以逗号和/或空格分隔的输入字符串进行切分。
1 A9 Z( S, h, w# B% ?+ V*/
/ v3 E4 C' M3 k6 w5 e1 h: O: k, Himport java.util.regex.*;
: h/ a- ?! N. W* J- d" r2 R
% ?+ l% N" N% tpublic class Splitter {
. l( h$ R1 Z! g  H* F6 z; l* `public static void main(String[] args) throws Exception {
# _/ k6 X8 C5 T$ o0 e0 h6 U// Create a pattern to match breaks
$ j0 w9 ^6 ]9 `; t/ [& Q8 wPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
) Q& T$ O; Y7 ^+ Q! G1 T* OString[] result =
   p.split("one,two, three four , five");
- a' s+ x1 p- o& ~2 ~6 g. T6 k( zfor (int i=0; iSystem.out.println(result);
) {' K% y2 r0 {2 \8 h}
}

Matcher类
$ [2 R; `/ M4 x% k
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
% a/ E- r3 s( C/ J" U7 r
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
3 l6 x9 a3 `) N9 I( u+ B% bfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
: e4 w; H+ m9 e9 |+ t% Q# a/ }. E
: u" ]# m, y& q6 `这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

5 Y+ S) L8 y1 Y5 }2 s6 p0 kappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
3 T4 p; p: T4 [
2 }. Q0 y. e; v例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口
% R8 Q2 c- [( U2 u- r
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
$ T7 K; f1 F: `- q9 A+ B
8 N+ {$ F1 x4 q7 o0 n  R  @Regex情景范例

( B6 K3 ~8 j# n: m0 T以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
, [. \" n6 O; g3 A2 W
简单的单词替换

/*
* This code writes "One dog, two dogs in the yard."
1 M8 k7 }0 ]0 I. Z) r# Z/ y4 d) N5 x* to the standard-output stream:
*/
import java.util.regex.*;

public class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
3 S1 `7 `" U0 T8 HPattern p = Pattern.compile("cat");
' f' Y0 N, ]2 e# }0 ]" N// Create a matcher with an input string
0 ]5 Z* g- V6 p( C0 oMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
9 [, o. _  A0 h9 P( Eboolean result = m.find();
// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
& F3 N$ b) F5 C) x# H" N5 presult = m.find();
7 s; M2 C! W+ _" R/ Z. m0 @  `}
! z( J1 L2 @. B// Add the last segment of input to
# v, n  r1 b) e- G! p& g) s7 M// the new String
m.appendTail(sb);
& t8 ]0 H# K0 Q0 u  p0 ISystem.out.println(sb.toString());
}
}
$ Q0 F3 @+ t% A2 `& v
& ?7 j& x) F4 I2 ?电子邮件确认

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

& Z6 k+ e* H1 F5 Z4 k/*
* Checks for invalid characters
$ I. }2 d" F+ w2 T0 C! t3 i; c! J* in email addresses
*/
public class EmailValidation {
public static void main(String[] args)
1 G2 |3 {  C+ S* ]( @( C8 ~( L& L$ }           throws Exception {
1 J2 V8 Y9 [* d2 [1 l+ Q           
9 S9 @' _  c7 y9 K% ?/ VString input = "@sun.com";
3 N3 j- B" W, V2 o! f//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
% u7 D0 ?0 q6 {- y$ iPattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
+ r  d) K+ D/ Nif (m.find())
System.err.println("Email addresses don't start" +
5 G2 W/ p  Z; F* [         " with dots or @ signs.");
//Checks for email addresses that start with
, A& x1 u; X# p$ }% X8 U5 A//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
' m0 ]4 v8 Y( f8 |* _& O   " with \"www.\", only web pages do.");
. C' n( B3 T, F}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
% f' Q5 O) X" T! Qm = p.matcher(input);
7 ^; x. F. S2 c7 {! o% Y; pStringBuffer sb = new StringBuffer();
6 Z4 F( c1 s& M! rboolean result = m.find();
) q: A7 n6 [. e* L" Nboolean deletedIllegalChars = false;

. u3 k6 Y0 [/ I# ]* Mwhile(result) {
* P. O' o8 d, {% e, M7 X0 t. `deletedIllegalChars = true;
m.appendReplacement(sb, "");
( Y7 R5 C& R. A0 L& U2 }result = m.find();
}

// Add the last segment of input to the new String
1 t/ U' S% y0 O; m1 V" Gm.appendTail(sb);

; b0 R* b7 d4 U( u9 Sinput = sb.toString();
' b: J- _& q: M9 Q5 n: m
9 v  n( ]2 }6 Z* hif (deletedIllegalChars) {
6 j4 N# g$ [  D- }* Q& ?System.out.println("It contained incorrect characters" +
' q( z2 F" A4 Y" l# z' C       " , such as spaces or commas.");
}
}
}

/ ?' H+ T0 h" D4 Y3 {从文件中删除控制字符
; v2 K. W7 |, ?" v
/* This class removes control characters from a named
* file.
" |) v3 e& A5 h1 t0 s*/
import java.util.regex.*;
import java.io.*;
) q) _& |. x, ?/ I
public class Control {
* i2 h3 d' w) l& opublic static void main(String[] args)
           throws Exception {
           
" z* V4 a/ g; x& n' P$ x0 r//Create a file object with the file name
//in the argument:
' }! f  P" B% g/ w' {File fin = new File("fileName1");
  D4 D3 o" c6 P. y+ c8 C! w3 N3 m6 LFile fout = new File("fileName2");
! t' P! ^, D( |; V; Q/ H+ u//Open and input and output stream
  g, |( ~4 L! PFileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);

) P# Z: t: Y# G) c! q# sBufferedReader in = new BufferedReader(
# o% X  Q0 B8 h, T5 J, w6 @     new InputStreamReader(fis));
+ _/ D) N- U0 j. p& c; r$ jBufferedWriter out = new BufferedWriter(
' m0 ~: Z# e1 L* p4 O     new OutputStreamWriter(fos));
; T+ c0 ~( o" O# u. Y
// The pattern matches control characters
* f# P7 ~, o  ?  K/ D* }- h! BPattern p = Pattern.compile("{cntrl}");
3 [; ]" U( }2 m1 S& F$ tMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
/ i  w1 n3 k7 Q, b8 Cm.reset(aLine);
" u& x' @% f6 h3 q: C. z+ B9 n6 f. ?//Replaces control characters with an empty
//string.
; K- O* N2 `& c0 i' m2 K$ UString result = m.replaceAll("");
out.write(result);
9 i- a- @* y1 b5 X: jout.newLine();
- i' ~& j! [7 q+ f9 E1 K}
2 H. b( ?3 |" t7 ?- hin.close();
6 R2 `- [/ m6 x& L6 Y$ r! Oout.close();
}
}
' g. b+ u' \. Q0 i
$ ?" T, @( _- B# S, |7 _1 G3 n: z" k文件查找

/*
* Prints out the comments found in a .java file.
& V; d9 B1 Z& A2 f*/
! q0 F5 Y: X3 Z+ G6 z) Qimport java.util.regex.*;
import java.io.*;
) a; D0 h; |+ [& J- p8 Z4 Wimport java.nio.*;
3 V# O1 A5 q3 l4 i1 k( P4 gimport java.nio.charset.*;
3 m4 \( q( ]& w( a' H! Mimport java.nio.channels.*;
1 e: F6 o* @% n! R. f- {& E& E
public class CharBufferExample {
public static void main(String[] args) throws Exception {
& H- K+ I1 g4 b* X// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

# f) V6 O* U5 L6 Q1 B+ E// Get a Channel for the source file
File f = new File("Replacement.java");
: M) Z5 Z7 T9 r( v3 e+ z: _5 WFileInputStream fis = new FileInputStream(f);
" ~/ J/ v8 O% H6 @( y& u' @FileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
3 \9 b3 Q4 ?- k& hByteBuffer 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);

// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
3 Q' s  l# L2 n3 @5 U% J" ~% uSystem.out.println("Found comment: "+m.group());
}
}

, ?& Y- [% t% C% I) m结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

- ]% U4 [- n0 n# d+ _" ]* dJDK1.4之正規表示式
. W, A- g/ v2 N" [* d5 r7 iwritten by william chen(06/19/2002)
. h( x6 e7 F  `& y; A
--------------------------------------------------------------------------------

0 @+ ?  D1 U5 m, j: {! x* h什麼是正規表示式呢(Reqular Expressions)

, I; G0 K8 g; Y3 @5 O就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
: F* M  k* g1 a* f( I
# p8 n. t# f0 w, D  P所以發展出一種特殊的命令叫做正規表示式
3 @0 V; G) L1 F
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
; m& n. P5 g7 P+ C4 g  g+ D
& E1 D  r2 k: t; Y' ~. j4 t. N若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
! f4 K% {' }1 P( {適用於j2sdk1.4的正規語法
, [4 p. }6 G. |8 W4 u5 J3 c+ ~
"." 代表任何字元

正規式 原字串 符合之字串
  Y. C8 G& b1 O, a4 z; z1 x. ab a
8 c. E  \7 W8 C( `: ^.. abc ab

/ j; d' A6 K' f5 E"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

4 f) j) u  d. w1 p正規式 原字串 符合之字串
' p+ u: |1 k3 M% t$ I! h: q+ ab ab
* abc abc

7 O# S; ?. n, J5 }  i2 {"( )"群組
) M) O# a4 b- z1 M. F% T) ?
: j  b* ?, @8 E. b$ ]正規式 原字串 符合之字串
(ab)* aabab abab

- U9 o9 a6 E! X字元類

8 d+ b/ K8 e8 q正規式 原字串 符合之字串
& k: L  p8 _6 E, u8 Q5 J6 B" t[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab
9 p9 q' u( V& \% q" l6 O
5 O7 v6 ?) B! e# q: [
簡式

\d 等於 [0-9] 數字
3 x, S# k3 H! N6 ~) z  B\D 等於 [^0-9] 非數字
' X1 Z5 }, n& ], @, A\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
* [+ v( {. k- o+ t) U3 f\W 等於 [^a-zA-Z_0-9] 非數字與英文字
) ^, C1 H! p6 a8 H4 c  S! l. J, }
每一行的開頭或結尾

% I" ]+ Y; \5 h^ 表示每行的開頭
3 k0 y+ h7 ?4 j- g: a4 L1 \' Y7 K$ 表示每行的結尾

--------------------------------------------------------------------------------
$ E* Z  S$ R5 G' C
正規表示式 java.util.regex 相關的類別

  m  I, Y, _. z% xPattern—正規表示式的類別
- c& H; F9 Y  y5 dMatcher—經過正規化的結果
3 H, S$ X7 t1 S- CPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
6 T, z! {6 F( u
範例1: 將字串中所有符合"<"的字元取代成"lt;"
0 D& A  q$ V, H  o1 X4 g) s
- N! u% J; y" B5 }import java.io.*;
/ J( N- S* `% z2 Nimport java.util.regex.*;
/**
. G2 T1 {# R; _! @% g% Y8 z* 將字串中所有符合"<"的字元取代成"lt;"
8 }. C! W' c5 E4 d; O  K9 r*/
public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
9 I& F/ ]8 u0 |+ C! d: DBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
# J, Q- H9 R" Iwhile (true) {
String line = br.readLine();
4 i9 D# p9 {( i; h; Z7 x" J# s+ Q/ `// Null line means input is exhausted
if (line==null)
" e: B# V3 @8 V* t- M1 g6 _break;
0 V+ G- j' h, ZMatcher a = pattern.matcher(line);
3 y+ o6 p/ s0 y( q4 I/ Gwhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
' c5 \, e+ A, L9 ^% [}

8 ]* p8 [! C9 v1 v範例2:

import java.io.*;
2 E- M, V7 y! Y( h3 ~8 o2 q& L$ p3 ]import java.util.regex.*;
- q) o# ]' b& |4 w0 l/**
. J& N& K8 O% p* 類似StringTokenizer的功能
8 C$ E$ A1 a. |5 h0 e* 將字串以","分隔然後比對哪個token最長
" L3 Y! X8 X7 R: Z6 N7 v1 w& g/ C*/
# V) b; X+ p  T4 H+ V- A1 v! Qpublic static void search01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
: }1 r, C# R/ C9 k3 \9 E# OPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
, s) |7 W0 s" {  @! jtry{
' f: W2 v: V% E/ T2 Mwhile (true) {
  r5 c8 f: [+ p4 h# H5 G/ v5 rString line = br.readLine();
9 R8 p, ]* r1 G9 D) Y( r% I# q6 iString words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
" E  F( O( L' C# R/ V% H& Vbreak;
: p! p( k) R) L# i9 @6 G// -1 means we haven't found a word yet
' @! k1 r  \) D9 sint longest=-1;
6 j: W  G; o/ z9 S" K! ^. R9 B3 ?int longestLength=0;
+ g2 v- e, p7 t" ^" h8 b4 Tfor (int i=0; iSystem.out.println("分段:" + words );
+ i5 J' c+ M' M3 X" n: \if (words.length() > longestLength) {
longest = i;
longestLength = words.length();
2 ]) ]$ U6 g6 x/ v# j$ N}
' o5 Q1 p1 n0 w. d}
6 p/ Z" \9 n- n2 g% x9 A+ J( mSystem.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
}
5 ]0 a" n- G7 q2 `! l6 U& b
--------------------------------------------------------------------------------
- p6 ~. q% G( }1 m
其他的正規語法
" _8 C' p7 R4 V) ], }
/^\s* # 忽略每行開始的空白字元
( a! `! W' h6 A' D(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水