关于正则表达式---ZT

Longe

第一部分：
, C- d1 d1 B% a) o: Y-----------------
9 o2 \. x7 B# C% z正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
; N7 h; b% u3 W
( i, e8 r- e) t. d8 t- b7 t支持多种平台

7 |# O+ k# o2 b4 ~
/ {/ Z5 o, ^6 R正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
. ^8 l: ], L  ]7 Q4 ]; w
; k" K3 `8 v3 C7 ?( C5 C+ Y许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
4 k2 [0 Y6 S  {8 @随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
# q6 t- h6 N1 X' |* x( f, F2 g, Z3 s) ?8 m
  g, ]% G" S/ R& f5 f4 P9 k正则表达式101
: d0 s, q6 A, j$ Y1 w很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
9 I& z8 V9 y4 b& y9 f9 _$ M
7 J1 Q/ u, }: r; n3 C第二部分：
* n( s9 d! j" i. Q0 O1 n/ M2 d4 r1 [----------------------
1 g# E' ~9 B5 q, R字符匹配
2 Y, p" t$ x* P9 `" t
; c! L& ~1 W1 C! S) [  }正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
9 l- j  r& J. R2 S6 ^2 y
每一个表达式都包含需要查找的指令，如表A所示。

! J2 s, T& P7 Z2 jTable A: Character-matching regular expressions
& K' r+ \% i6 ]% e6 h格式说明：
( B2 @4 y0 Y5 x  W2 Q---------------
操作：
解释：
例子：
- ~- b! I( K2 b0 F4 |$ j, l3 I3 y结果：
' {+ D. t9 f/ I# h----------------
3 x& g. I( z/ c: \.
Match any one character
grep .ord sample.txt
4 \& K# ?: e% ]& v7 gWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
Match any one character listed between the brackets
3 V) o& ^" f& l7 m' I8 ]grep [cng]ord sample.txt
6 ?! z+ u& M1 @6 V8 qWill match only “cord”, “nord”, and “gord”
+ f/ l# j  r+ H4 d---------------------
[^ ]
, _& a1 H8 [& g- wMatch any one character not listed between the brackets

5 I8 m2 C+ n, Fgrep [^cn]ord sample.txt
1 ^6 I- I6 F# |1 _* [Will match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [a-zA-Z]ord sample.txt
8 k1 z3 }' F( j* J8 x1 Q) R  RWill match “aord”, “bord”, “Aord”, “Bord”, etc.
9 ]4 H2 F# ]; n
4 @' S& S: [* \! |! n* ]' G1 ^3 mgrep [^0-9]ord sample.txt
: B( P: Q: s; B% S6 iWill match “Aord”, “aord”, etc. but not “2ord”, etc.
' }) r6 C& H! I+ i0 ]4 h, i
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
- F2 ]8 z- r1 v
' O2 \5 X- h; K8 l3 N6 DTable B: Regular expression repetition operators
格式说明：
- q+ r  I, v* _& F0 r---------------
操作：
6 Y  O5 e  w& N- ]解释：
例子：
结果：
5 i/ b" }! Y7 E  V' y$ x----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
) n7 O2 P" D# l------------------
*
Match declared element multiple times, if it exists
% [# A$ T& G+ legrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
6 [( X$ B' O% d8 w* z5 e7 v+
Match declared element one or more times
egrep “[n]+erd” sample.txt
. C6 Q$ w7 e6 C5 [' B+ I' z# i6 Y7 o- A  q9 cWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
0 S. u: r7 Z2 D% {8 T  R{n}
& t/ Z* z7 e& v5 `" Y% ?" \5 CMatch declared element exactly n times
6 Q- t! ?4 }2 q2 T. x$ p7 G) H) qegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
7 J, p6 k1 F; t  r5 F1 Y{n,}
Match declared element at least n times
0 |& v+ D0 r7 W) ?) g7 zegrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
Match declared element at least n times, but not more than N times
! J) F" N8 |1 A0 W8 yegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

" l3 m! U, f8 p' W$ C第三部分：
----------------
$ M9 N2 c5 R7 [1 t- o- c锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/


0 ]7 I* E+ l8 h* y, {Table C: Regular expression anchors
-------------
/ f+ Z, v- Z( k- c& w操作
解释
例子
2 A. D1 p) {- z* P) V结果
---------------
^
Match at the beginning of a line
s/^/blah /
- [4 w) v) i9 x* |5 l+ e5 PInserts “blah “ at the beginning of the line
---------------
! r; i9 b# D- k: ]; k8 B$
( A9 T# R! z6 O: tMatch at the end of a line
, M. F% M: T' ls/$/ blah/
) H9 d9 U# f6 H$ y0 ~Inserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
! \: y; _' D7 _$ `: H
# n8 F6 A3 l1 I1 e+ b8 Legrep “\Matches “blahfield”, etc.
. q. o. M" w0 U6 G5 i$ t7 u------------------
( g2 M! }" b- }9 v! F; c( y\>
Match at the end of a word
. K2 [+ X- M" k7 |$ As/\>/blah/
Inserts “blah” at the end of the word
- }' [% U+ S' w( a
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
1 ?. U- x9 C8 k0 p$ G, u: Q: Z---------------
\b
3 P# t4 m: b9 vMatch at the beginning or end of a word
egrep “\bblah” sample.txt
% N- M" r1 b! ^5 f3 YMatches “blahcake” and “countblah”
-----------------
\B
4 e8 f- M" ]" z/ m. w6 h! UMatch in the middle of a word
; m& Q% N7 f6 \: Z7 hegrep “\Bblah” sample.txt
Matches “sublahper”, etc.

间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
6 J1 x7 t" U7 }7 J- s- D
egrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

! L9 \' M% R  P3 f9 Begrep “[nm]erd” sample.txt
* I) S. {3 {  u. d/ v1 E* K! ~
% y* i. N# J- b- p* C$ o当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
; [+ _2 f; _3 b1 d* O" l
6 P: W6 o# y7 X  {第四部分：
2 i8 i" g9 D; c; V# Z! ]----------------
一些保留字符
, O% q! E+ Y, t1 pRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

& }. O8 A  O7 j7 d& m: x^ (carat)
, I# P$ E, o- ~+ _. (period)
' l; k) r. A7 l' R* `; @! m  p[ (left bracket}
$ (dollar sign)
( (left parenthesis)
4 o- t' F% i# B) o3 c) (right parenthesis)
) j0 S' j# ~2 ?" }3 m| (pipe)
* (asterisk)
9 _) v1 P& ~3 l" R+ (plus symbol)
' t. `) N; N& l6 Y2 ?? (question mark)
$ k% |- @0 K# _7 Y$ O) x{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

  A4 f) D. z$ I0 {% T& T8 Q0 o5 X1 heregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
" k8 Q6 X5 l% y& t$ B7 Y  Z
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
5 b. c& ~" S% ~% D: V  c
总结
$ B1 y5 @( y1 e) P在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
. y4 w6 l! ^1 }4 a
# Z# x4 R, j9 B3 x! E& ^+ S另外一篇文章
3 z" I5 h# k  }----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法
/ F8 Z& x7 k# Q1 H6 j! ]5 f  p8 J
下面的类根据正则表达式指定的模式，与字符序列进行匹配。
2 Y" M  W- Q+ {  e8 C+ Y
& e% ~5 w3 D5 G1 R4 MPattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
" A2 d& G( A1 v
  \8 m  {) L3 `/ h  r! \) f2 c用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

2 p" b# y; l8 l$ n" c& A用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

0 Z1 t. R* }; n6 k# k  D4 |; m/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
3 i, w! D$ |3 p; P0 {- P*/
4 M; Z  d, W( A. i8 {import java.util.regex.*;
9 V9 g; Q& y/ _% c) u: w
3 u$ f* w5 x( e) dpublic class Splitter {
public static void main(String[] args) throws Exception {
, f- k' r4 u& b: ~+ s/ \2 h# y8 Z// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
0 f' E4 R. q, X9 K/ |String[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
' b4 d# ^3 G# |3 E. T}
, ?2 E9 s& x5 F9 c+ \/ @4 h& R}
0 k5 b8 s: K1 y+ [6 d
: j6 ]3 V6 {7 c9 cMatcher类
, B. P8 b( x( A0 {
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
1 e* ^& z2 U' ^) F7 c7 d
) G* _0 n( t. X) g通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

+ {/ Q) ~7 Q8 e. E& L  X# vmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

& t. k% V; i& T8 P& l) l这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

) q; r* d; g0 `: p: e  A& k这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
( _, q( s& p$ g* Z6 ~
+ q6 a' Q( E% lappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
+ Y; V8 x6 `) U9 V5 G" H: w7 ~
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
7 p# Q( B" e% m! v, \* x  ]9 }
CharSequence接口
  ^6 R( @  Z! l8 \/ S
7 D8 {4 }* a- i/ D% L5 RCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

Regex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
' k, Y2 H0 w2 |4 u, o: D: B' Y
/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
" S) V+ L6 Z, ~; @) n*/
( }+ o) z3 \* H5 q  R9 y* Gimport java.util.regex.*;
3 W4 W0 n2 q/ X
public class Replacement {
public static void main(String[] args)
       throws Exception {
' _7 O6 m8 G8 i6 Y// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
& a* C  }: G8 {3 s" s0 [     " two cats in the yard");
StringBuffer sb = new StringBuffer();
; v9 `& |$ _: [5 B' C; p# m( ^boolean result = m.find();
// Loop through and create a new String
! `7 F9 G/ ^# X$ ~: ]5 S" \// with the replacements
6 Z+ A* }( ?0 R+ |$ owhile(result) {
- V& O' f+ ~- Nm.appendReplacement(sb, "dog");
! @1 P' k% c1 Y: [! M; q* Jresult = m.find();
}
. n7 ?- v  \( P, l0 y- L// Add the last segment of input to
// the new String
m.appendTail(sb);
* \/ C) L( S5 O+ z$ m' F( y$ tSystem.out.println(sb.toString());
( d. H, }8 \1 l}
}

电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
, N: W  a2 c5 c$ ^( Y
0 X; B$ Y( M, V8 ?/*
* Checks for invalid characters
" C6 Z' H1 |$ @* v- o: ^* in email addresses
*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
' T* p6 o0 n- [. hString input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
; M% y- D" L- S6 u- |& EPattern p = Pattern.compile("^\\.|^\\@");
* @! T+ |4 Z& o9 s9 iMatcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
6 M" [. Z- t  Q' Y         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
3 L3 y" d6 C' K/ ?) S0 Um = p.matcher(input);
: I* U9 F2 \% F) [1 k. M. {if (m.find()) {
System.out.println("Email addresses don't start" +
: D$ ~* D* X# ^: n1 m3 p* t9 X   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
3 O0 ]% E5 J* k! j% ~: _
while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
( V. T8 M7 q2 s7 V+ w5 wresult = m.find();
}

// Add the last segment of input to the new String
m.appendTail(sb);

$ w4 c- ]# G2 E) W& G, Ginput = sb.toString();

/ a! C9 ^3 Z. J( U" Nif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
) X( R" x+ c) B$ U3 [       " , such as spaces or commas.");
}
0 |" t' o' N8 @5 }1 |' q( ]% o5 a}
}

从文件中删除控制字符
$ d8 N+ V0 P/ @0 |, O3 p4 P- a
' _# \* E# `0 Z3 V1 R7 `4 V2 x0 R/* This class removes control characters from a named
# T6 u! A, |' u* file.
" ]4 J! L# R# D: W. h- D*/
" K2 o7 A  \9 h- ^import java.util.regex.*;
import java.io.*;
' ^* q( F. f& j! _0 g3 C0 a# Y
2 ^2 G. M- j6 q; wpublic class Control {
public static void main(String[] args)
           throws Exception {
2 @2 q4 A6 ^; @. Z: C           
//Create a file object with the file name
//in the argument:
+ p7 d/ |; g5 @File fin = new File("fileName1");
File fout = new File("fileName2");
) d" [( b7 [3 Q$ Z! b# ^# n  B" \//Open and input and output stream
4 d2 u' \% ?* f4 G1 L4 a! f4 ?FileInputStream fis =
5 M7 y  b2 C. ]5 S! P6 O' O/ e( C       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
0 s# L, V5 N) Y- ~' {( z$ o0 A6 W" {
4 E7 x, h" U) [; nBufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

' G: `' z% y/ f4 _8 x7 e/ A0 g// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
, S( ?. W! D9 |$ g7 xMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
' I( }0 g$ u$ `5 @  h//Replaces control characters with an empty
1 Y5 T3 u; R1 e5 X2 _9 M* V! h( x//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
4 a1 P$ |" j0 l1 ^+ Z}
in.close();
/ E. w' O7 ^/ L# E! ~1 {( {' j+ dout.close();
}
4 f) M- ]" w/ e, h: n}
9 c( P) l- L* W2 m) V, |% N
文件查找
4 C6 y# e! b; A' e  r7 X# J0 `
/*
7 S6 G  z3 i1 ]$ [0 Y, v5 l" `* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
% p' y# V2 e  y* a5 _  pimport java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

) q# Q; b1 ~- Z  Q( Gpublic class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
& R1 j- X5 [" C* Q4 c9 p7 fPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
4 }$ n; L1 P% p$ ]$ Z. ]/ C
8 w2 J# s- f% ?, d+ ^/ p$ ~! P8 R5 k: z// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
# [5 w6 ]  j) _% x% D1 [% |, SFileChannel fc = fis.getChannel();
4 i8 m6 t0 w; q: q* W+ Q$ J/ }
/ t- [; ^: k, W1 Q6 D+ l8 g7 s// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
! D$ J+ K1 Z+ P7 W3 `' DCharsetDecoder cd = cs.newDecoder();
9 V& O! ?& Q+ I- _% @% L% FCharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
- h' n0 l& v) [; Kwhile (m.find())
, \5 v* @9 n: M. v  W# nSystem.out.println("Found comment: "+m.group());
}
* q* q3 D! i1 P}
! W  R& N% B& s' V0 I5 k  a5 S
# z- Y5 y! X$ a0 \结论
( |/ {6 u& x; y# k现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
: R: ~0 S$ \+ s9 H  }; Dwritten by william chen(06/19/2002)
) E% s/ e6 h: D% X: [! C8 Q
# T$ U- u: D# B/ d" `+ j--------------------------------------------------------------------------------
5 D, S6 `# W! H2 v
什麼是正規表示式呢(Reqular Expressions)

& o) c) B( Z* Y5 A就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
% [) M: h; Z' |) U/ \+ h+ _
所以發展出一種特殊的命令叫做正規表示式

. \% A! B6 [7 \# y1 Y7 X4 G2 f我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
1 C  J9 D. [4 R4 b$ f' m
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
8 i' Y# U8 {. p; y" u/ p& @
% I8 A# I& a9 l2 j: a; h剛剛列出的一串符號" s/
) P! i. g6 b& `% y8 x適用於j2sdk1.4的正規語法
' _; w7 s, I7 Z9 f/ v
"." 代表任何字元

5 [/ e2 y& k( E. t! l" J正規式 原字串 符合之字串
. T) Q8 d: x& m. ab a
.. abc ab
: P# ~' ^3 h, @6 L
% [8 G6 y+ K6 v8 ~* c"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
3 b4 n5 t) b+ ^; [, f+ ab ab
* abc abc

! c9 z1 z; N1 s# z2 \# |"( )"群組

. h! R0 c3 B) I正規式 原字串 符合之字串
(ab)* aabab abab
1 c. {+ ~. J1 M
字元類
5 Q5 {1 w' T; F& h: E* M, p0 _
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
% H$ c8 W2 T$ m+ k/ l[^a-d]* abe0 e0
/ J1 U  |7 o( A2 ]- @# ]8 i[a-d]* abcdefgh abab
: G3 Z: c; r; {; H
4 C( a* o5 l, h! m3 t
簡式

+ j, [7 `; g2 l- Z  i4 o3 ^9 f\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
$ J; k/ ?' @! I1 Y2 j- ~0 s\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
7 ~4 I6 N5 m3 i* }
  r) y; W8 }9 @1 ?' _) n5 s每一行的開頭或結尾

5 d8 j. ]% o8 a0 `: n" ]- _" M^ 表示每行的開頭
2 i3 d$ F! M& Q' {$ 表示每行的結尾

/ t- Z" }8 ~; d, C8 R% I--------------------------------------------------------------------------------

正規表示式 java.util.regex 相關的類別
! D/ g1 R' r0 o9 F3 I' p2 s* G) F
Pattern—正規表示式的類別
: s6 h$ U; P0 DMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

! ?) L- V- h+ z. n; u範例1: 將字串中所有符合"<"的字元取代成"lt;"
; e1 ^& V$ r/ V. h3 g( i9 I; X
import java.io.*;
% R8 t6 C& N3 G" nimport java.util.regex.*;
% R& G0 q$ W" }" Y- m6 K/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
- x! }  H8 k1 x$ R9 G) J8 \// BufferedReader lets us read line-by-line
# M) s/ T# _* Y2 f0 t4 iReader r = new InputStreamReader( System.in );
1 o1 S1 j5 E. sBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
5 w" d1 j: p+ O& l8 a0 E6 [8 btry{
while (true) {
String line = br.readLine();
// Null line means input is exhausted
: R: x: N- H8 E3 q; wif (line==null)
break;
* r$ {1 S  i6 R3 eMatcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
/ f& d  T/ Q! a" j9 _6 l' O0 O}
. E: @; y8 n8 S: KSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
, ?8 M+ j  v5 X, H/ m' c}catch(Exception ex){ex.printStackTrace();};
) B- U( Z+ D  t; ?9 W8 J" l0 |}

& j8 f6 W, [% z範例2:

import java.io.*;
import java.util.regex.*;
/**
& O& \& X# G0 ?* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
, d$ Z) L6 \! c7 X% bpublic static void search01(){
// BufferedReader lets us read line-by-line
' U. s" n9 A. S1 o2 TReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
5 r! V. C& P3 rPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
8 F! n  _! o0 W0 H$ `7 }try{
while (true) {
String line = br.readLine();
9 ^6 `. U0 P/ G3 r6 N! D. [7 k' yString words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
) T2 I& s) e5 [7 z$ B2 a; r: M% g// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
* B' }( t# b* ]8 W3 H4 E: Q5 Rfor (int i=0; iSystem.out.println("分段:" + words );
9 L9 P  }, u; z- v$ @/ fif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
}
) n2 ~9 J; l! d; w' b  m% y/ m8 m}
! @& L; z% z: X# m9 V6 ]$ s* tSystem.out.println( "長度最長為:" + words[longest] );
& e0 V5 ^$ o. V. m# U0 d}
6 z" o) l) E0 o% E# r7 [+ K1 H) j% {}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------
0 L3 M# x' h8 J1 p9 g& F* r; v
3 `1 ^% z2 u! J$ g! P; R其他的正規語法

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

一叶

一头雾水