关于正则表达式---ZT

Longe

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

支持多种平台
# h2 U+ L% p6 _$ R! O

9 r4 J* `) [. W- ~6 z- A0 _正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
0 K: W$ I2 W) X8 k; r$ x, c; ^
8 c0 g" _7 L2 q/ f0 W2 v: z7 `8 p正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
! F8 b) b3 x1 `4 s$ }0 U* ^
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
! a9 G8 e  ?, t9 B
比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
  Y9 N4 ?4 `2 q8 a6 a/ u! W1 d
正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
* i7 D$ y1 ?) c" e, p4 \5 `3 m3 d
第二部分：
+ N$ ]8 a" J# x4 h----------------------
: k$ R! N' B8 w3 V字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

每一个表达式都包含需要查找的指令，如表A所示。

+ s7 ~" V! e/ ]6 `# r& J- @! uTable A: Character-matching regular expressions
6 A6 X# O' T$ X1 }$ ^/ g; y格式说明：
---------------
8 M7 q- e/ @5 _( b操作：
. Q; b/ [: P7 `解释：
例子：
结果：
----------------
.
Match any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
" S+ ?/ p: v* F-----------------
- G% A9 N6 f. @# \; q. {[ ]
+ l; z' G& _2 K9 x" BMatch any one character listed between the brackets
grep [cng]ord sample.txt
. g9 Y' j' s/ p1 f$ o* l( c/ j* xWill match only “cord”, “nord”, and “gord”
---------------------
2 }) O3 Q9 `- _' J: {; Y: u[^ ]
  |* p$ F- M: ]2 D! S' r: zMatch any one character not listed between the brackets
4 a( z* x# v, M* K  z8 A7 y0 B
. K# M, {% v& n" sgrep [^cn]ord sample.txt
3 S6 n, @: H0 k  [" [* k: \Will match “lord”, “2ord”, etc. but not “cord” or “nord”
- t! ]) R' n9 b: y; s. H$ |
  S, S( w" z- egrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

. h4 S. R# V* G3 n- Y, Zgrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
- D+ P' a# V4 c, M5 B9 p" H6 ?
重复操作符
5 O* p, h! E4 g2 T$ F) C; q% k重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
) p' @. {5 v, a5 `1 @/ q: v格式说明：
---------------
操作：
解释：
例子：
" v8 @2 T0 K2 ~3 u+ A- k结果：
----------------
! {  ^3 Z* S. T4 Z?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
4 D3 B5 K: \8 Y6 d7 L- [8 x------------------
*
Match declared element multiple times, if it exists
  {% W* F$ _$ d) qegrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
" d- q, ?" X' N-------------------
+
7 ?# D; c3 M' \9 N3 k! }, ~Match declared element one or more times
egrep “[n]+erd” sample.txt
4 L. C$ j; N; x- Z. m" PWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
% r5 _! B5 `5 H3 B$ e; W{n}
5 Z3 y" t8 p2 j! Z% k5 r! M: z0 {; kMatch declared element exactly n times
) p' `" p* K' {+ b4 \$ w" u+ k( R" {egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
  k" Z$ ^2 t5 ?& C2 O0 A$ c{n,}
Match declared element at least n times
" J  I4 i  K* m6 H; Tegrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
- N4 x% X8 A% E, z! c: M5 W{n,N}
2 I% s9 ?, M2 m8 ]( d- bMatch declared element at least n times, but not more than N times
* |4 J& C7 u6 T4 Y) Xegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
% R. a+ a/ V* s1 N
第三部分：
----------------
% l6 _/ b+ ]5 A  K3 x锚
  {8 u9 J/ b* T% ?锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
9 c" F4 s- K) y9 L3 U. u4 ]. H# f
s/pattern_to_match/pattern_to_substitute/


Table C: Regular expression anchors
; B- d+ F, T, g9 \-------------
; p9 s, \8 \0 @' Z9 H% j操作
解释
例子
结果
---------------
^
  P9 b3 Q& w5 \Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
" B% w" t: ?1 O---------------
  e8 N, }2 }$ u  }6 G, p- h( i9 I0 X$
Match at the end of a line
; g- r+ [5 _% g& }s/$/ blah/
2 D$ {" B3 i0 x! q& A( tInserts “ blah” at the end of the line
" f$ M4 j( ]3 F8 F---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
( a! V* {" B/ O) S+ F# N
egrep “\Matches “blahfield”, etc.
- f7 q% p- r' d, r3 }5 [8 k------------------
\>
Match at the end of a word
s/\>/blah/
6 R7 W5 d3 _) T  {# DInserts “blah” at the end of the word
# |4 K0 s% g! f0 A$ X; ?
egrep “\>blah” sample.txt
  U/ I+ Z. O7 S! MMatches “soupblah”, etc.
. j& v8 h9 ~; O# x---------------
\b
/ \7 u4 |  }- c% U1 ?Match at the beginning or end of a word
1 l! z# Y' \. S9 _; S8 Begrep “\bblah” sample.txt
: o7 @3 e- r7 L1 l6 `Matches “blahcake” and “countblah”
& M9 c$ `% I  r5 ^0 P-----------------
\B
Match in the middle of a word
egrep “\Bblah” sample.txt
% b  X1 B0 t2 o9 M2 `Matches “sublahper”, etc.

, Q: ^6 X( Y3 A间隔

/ B4 W' D( X* T9 L3 S: s2 M& ERes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

egrep “(n|m)erd” sample.txt
- h4 }0 s; ?; i
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
. v: ?/ @  D. U, R. o
egrep “[nm]erd” sample.txt
% f3 _3 ~/ A) z: P
+ n' s+ p' d8 C6 Z0 P2 r当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
& T* w1 r, B% R; z& J
^ (carat)
4 v8 ^, K  {* r) [6 U% Y! ^, A) F. (period)
/ {: w! V. n9 A3 k! M[ (left bracket}
$ (dollar sign)
( (left parenthesis)
# a9 N" H  k5 N) (right parenthesis)
1 B# e1 P0 o! f9 c7 i. U: o| (pipe)
: P2 r) D4 o& V8 n$ k- K& Y5 H* (asterisk)
+ (plus symbol)
? (question mark)
4 \1 @( H0 m6 d, s{ (left curly bracket, or left brace)
\ backslash
5 v* b$ j( j* f! X+ U9 \一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
5 ~9 _5 T( Z: R$ P& }2 A6 O4 j
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

! `4 X, \) R6 P你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
( [! r/ o1 ?& i5 E在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
: G+ j6 a( w4 h2 D. B# p
另外一篇文章
----------------------------------------
& K0 _: U7 s+ V( W( |& S& `正则表达式和Java编程语言
-----------------------------------------
类和方法
3 o0 z3 n% R2 F% w
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

+ c  ~+ P& a. l  lPattern类
+ S: o1 }+ C+ d6 l
5 x$ r7 B: I/ d9 `+ OPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

. ?; b4 Z8 e3 v* I2 u用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
. f- i8 \& K$ z0 b
0 b* `1 P1 c2 u# U2 V# i用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

5 q1 G8 Y" b9 @5 D- ssplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

) R0 ^+ c6 t  N/ |- I' a1 g2 W/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
' j, w  Z- p0 r! N" w*/
import java.util.regex.*;
+ w& ?" T- e: V/ ?+ G% r
public class Splitter {
- Q  P+ G7 j1 ^" F0 I% npublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
( g5 L$ e( }$ w0 f0 nPattern p = Pattern.compile("[,\\s]+");
+ k& k/ g  F. O/ q8 H// Split input with the pattern
8 \4 |/ |3 S9 k: F0 l# aString[] result =
* I9 I% y- U# g- `/ ]/ B9 e   p.split("one,two, three four , five");
! |* i- F1 B' m2 I; Wfor (int i=0; iSystem.out.println(result);
}
}

1 p$ j' y  Y0 g  x9 yMatcher类
+ A) ^( D- y/ e* y( R
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

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

8 s) W0 B8 ]( }+ [6 bmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

, M  m1 I7 }6 h4 ?# L2 z9 ]5 H这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

. z7 \) W' S1 |8 B5 h4 uappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
. ~# J4 w9 Z$ S8 K% L' a) U, a4 f
4 I! D+ W- g  Z7 Y+ e* ?* g3 T例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

' Z; u1 q' y4 Z0 K( ^CharSequence接口

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

# A: v8 T; O, ?% X) IRegex情景范例
1 K0 q. a: _) H! Q
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
/ t6 T; V" J# r4 x
) o) v7 i' R! R( x8 f5 r/*
* This code writes "One dog, two dogs in the yard."
9 l# D: S. s- A2 H4 E* to the standard-output stream:
*/
6 k8 S' g: v3 z# ~  yimport java.util.regex.*;

$ k; d- e: y3 S3 [+ }, u* [' zpublic class Replacement {
1 F* I9 g- y; c0 G1 H) N1 L4 a: |public static void main(String[] args)
       throws Exception {
0 J& }5 x8 N; G& G' v, Z8 d% {// Create a pattern to match cat
8 M# {3 ]2 C+ J- T+ ]( L4 @9 bPattern p = Pattern.compile("cat");
% h) X. t$ t0 t7 [! e+ l2 j2 }// Create a matcher with an input string
& b: E0 M: _0 l  JMatcher m = p.matcher("one cat," +
     " two cats in the yard");
9 F4 O2 p; e7 s; n: @- t3 kStringBuffer sb = new StringBuffer();
boolean result = m.find();
, T2 F% H  ~: b* n+ Y3 I  Z0 r// Loop through and create a new String
1 @8 P, l, b+ P* S// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
( A5 Z) U: v$ @( N}
* f2 U- y& b  G4 M4 P1 f! f// Add the last segment of input to
// the new String
9 S+ B0 b/ c. q% w& \: v) _$ D  |m.appendTail(sb);
/ S0 c6 ~$ X( l( ^" g3 R2 eSystem.out.println(sb.toString());
}
}
0 X2 m6 g, \$ e7 b, s3 H' x
电子邮件确认

7 I& K' U1 r4 u& C- t以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
8 C; w/ I' {3 J
/*
2 V# {9 g& J$ D2 e% `1 q( X* Checks for invalid characters
' D5 S" Y" O; f6 J* in email addresses
*/
$ ^, p1 w7 ?9 lpublic class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
7 Y, I! ^& c" X2 u7 S7 e& J7 ^Matcher m = p.matcher(input);
" L) M7 g- ~3 D7 rif (m.find())
( J) j' j( @1 F' z: u0 Y9 `System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
( H5 |# P9 |. m* \( z; j//Checks for email addresses that start with
0 Y( G& W. r( n$ z& Z  T//www. and prints a message if it does.
" i0 h2 {2 ~8 u/ ip = Pattern.compile("^www\\.");
/ Z7 P% v- _3 ]! M5 hm = p.matcher(input);
if (m.find()) {
/ X6 d, }2 R" Z5 |$ _& l1 HSystem.out.println("Email addresses don't start" +
% ~/ D# F$ S8 w7 R   " with \"www.\", only web pages do.");
& n" a* Y+ p5 y! v" E- b}
2 [) C2 }6 ~0 Np = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
/ y# E* B9 X) A' Y( [boolean deletedIllegalChars = false;
, x! @9 }1 A- _+ h1 d- s, x8 C6 R3 p
( ?# [$ q1 A, s- ~% A/ ?; Twhile(result) {
4 v0 C4 W/ u3 }3 Z. `deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}
  m, m+ x! g7 i( Q3 @' W
// Add the last segment of input to the new String
! j* v5 l$ i# D) \/ Y7 ym.appendTail(sb);

input = sb.toString();

if (deletedIllegalChars) {
* F7 s& X% p$ \% Z& S6 E( _System.out.println("It contained incorrect characters" +
: N4 Y  i( P+ a, c! @       " , such as spaces or commas.");
}
}
& E' i) k/ a* u  Y! K' K2 A' ?1 Y3 L}
  j' ]: c9 E, L
; M9 P% s# }8 X从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;
6 d" c" N2 F7 y: r- y& a
/ d: I5 V8 g; k' s# C/ r, f7 C0 Spublic class Control {
public static void main(String[] args)
           throws Exception {
% {" @; B, L$ }2 `! `' B0 \3 h9 G           
) @- e. P" L0 q' O//Create a file object with the file name
$ L9 f) x# |' k- a8 Y//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
0 x* j7 z1 c; A% \% |FileInputStream fis =
       new FileInputStream(fin);
# U$ m! M. \3 z3 @! ~FileOutputStream fos =
5 X! X$ }% T2 i7 M! h2 u       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
% D9 }9 ?' k/ ~* I     new InputStreamReader(fis));
8 s2 k. [' G; g, k( o& |BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

// The pattern matches control characters
, v* o  l- W, cPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
+ e+ A, Z; ~. S& R6 z3 eString aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
4 S+ u- ~$ q5 n+ MString result = m.replaceAll("");
/ M$ ]3 B8 m7 F9 y& iout.write(result);
; J) X2 I/ I$ B0 d, zout.newLine();
5 K( Q5 ?% _0 W9 _- S. F}
  B3 O$ v8 i# U: S& Ain.close();
8 F. G  @5 Q) q/ ]& s& V! q" h. gout.close();
}
}
4 h3 b1 C6 x# s6 @% |
文件查找

/*
* Prints out the comments found in a .java file.
*/
" Z) Z; E, P# Z7 z+ {import java.util.regex.*;
2 U7 c6 z/ ]' w$ A# x( uimport java.io.*;
; o, S% O/ s" k* Uimport java.nio.*;
; b1 b3 F5 ~5 A6 C: aimport java.nio.charset.*;
5 k8 c, p4 U9 t( }+ g; g* f. ?import java.nio.channels.*;
, L5 t% g- C1 z( E; K+ w
public class CharBufferExample {
5 `# ?3 E; ^7 X5 X% S# N3 o0 {7 ]public static void main(String[] args) throws Exception {
& C" V; t+ X- Y  l" r// Create a pattern to match comments
+ i+ X6 P" E! h# v3 q* K, M; FPattern p =
! i: e1 O7 D( [4 E* n% ]) |Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
4 r# _. q9 j2 }( g# AFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
# U2 N7 ?/ u0 m, vFileChannel fc = fis.getChannel();
9 C9 w: E8 [  D+ a
// Get a CharBuffer from the source file
( {9 f# h) b1 `0 }3 ]: E- F6 dByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
2 _' u) {8 r( ^" U+ QCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
% N6 l) s; P/ q! D8 eCharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
/ a) T& G+ M  p0 Z2 [/ ~3 p! k& Awhile (m.find())
System.out.println("Found comment: "+m.group());
}
. q/ U% ^  R1 I) i1 z$ n6 Y/ M9 g}
9 c) R4 p* @( c4 H) f
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
& i( n4 u: \! j* h
JDK1.4之正規表示式
written by william chen(06/19/2002)
+ J) y) G) h9 a) @- w" y
2 J' f$ s' Y2 h8 t& O# [--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)

& d9 q, u6 |# ^. m6 j就是針對檔案、字串，透過一種很特別的表示式來作search與replace

4 t8 a4 f& [3 K+ Z1 Q3 U8 b因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
# i6 D# h( \7 i3 c, x2 Q5 w
) X/ K' f4 z2 X7 G所以發展出一種特殊的命令叫做正規表示式
9 X, ?- N- m- P2 r1 d5 e
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
! H: ~  q* E# z. w' f& A
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
& B1 o$ u7 n  F1 T- E# ^# B
"." 代表任何字元
+ {; q, }, _& r2 w6 \# S+ u4 N+ Q# y
& N7 I$ m9 m: D' B" v3 u正規式 原字串 符合之字串
6 g8 K" I1 S# F2 q2 S. ab a
.. abc ab

0 ]% r3 q% \8 t, Z6 X"+" 代表一個或以個以上的字元
( e/ B4 d5 R( h. R% {7 }"*" 代表零個或是零個以上的字元

7 S1 y4 y) T% Z3 G正規式 原字串 符合之字串
+ ab ab
* abc abc
2 E! c1 h2 e3 W, @( ?
"( )"群組

正規式 原字串 符合之字串
8 z3 ?. J7 g8 O1 G$ ?5 z(ab)* aabab abab

, v  u: v: `& m7 u' `  ~字元類
# l- {5 @& G& C6 _# S" n0 B- g
- ?" u( n* N4 i' e正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
7 J% B* l) u$ K, w% y[a-d]* abcdefgh abab


簡式
6 Y* P, R1 F2 d- |* q# U( O
\d 等於 [0-9] 數字
$ I+ U3 g7 J1 t3 P( r7 s- b\D 等於 [^0-9] 非數字
+ L6 f9 g, [$ O6 ?% @4 {\s 等於 [ \t\n\x0B\f\r] 空白字元
( s3 i7 ?9 B& k; d\S 等於 [^ \t\n\x0B\f\r] 非空白字元
8 ^$ V2 K, |3 F* R5 N\w 等於 [a-zA-Z_0-9] 數字或是英文字
( ~; o+ b) y. ~9 B; @\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

^ 表示每行的開頭
9 }, A" m+ z7 l3 l$ 表示每行的結尾
# b" F/ R! V+ Y5 v! c* o
1 H& _, Z4 `- p( N! g--------------------------------------------------------------------------------
7 J3 C. v3 m; W0 v' p3 R% z* z
正規表示式 java.util.regex 相關的類別
! N6 |# J+ C! l0 s
Pattern—正規表示式的類別
Matcher—經過正規化的結果
* Q, H' |5 W9 a7 h+ Q7 JPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
) C* t0 D9 K' p# T- {+ b0 e
5 ~- R( ~# J1 m1 B$ I範例1: 將字串中所有符合"<"的字元取代成"lt;"

7 q/ W5 m, `" Rimport java.io.*;
import java.util.regex.*;
/**
, y8 k) v( d% |0 L! U* 將字串中所有符合"<"的字元取代成"lt;"
*/
, y3 Z. H$ L/ m1 ipublic static void replace01(){
/ V* m7 v& Z) R' K$ A/ p& k& m// BufferedReader lets us read line-by-line
; x. x0 @1 ^, h/ k9 \Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
String line = br.readLine();
// Null line means input is exhausted
" f7 C2 F5 P) y% ?9 T& }4 Uif (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
. N$ @2 }" P+ @* X' L. lSystem.out.println("搜尋到的字元是" + a.group());
$ f% ^' |* @! _4 @}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
) t% [: P; @* R# J, G' S1 h}catch(Exception ex){ex.printStackTrace();};
$ Z: o' j9 ~/ y  K, H}
! \1 w& m! j9 M$ G
9 [  b) i& r8 n" L2 X  W) G範例2:
2 W( Q& ?( x# s  o. a: [
import java.io.*;
% s) f  s  }& t6 w: M5 Aimport java.util.regex.*;
/**
* 類似StringTokenizer的功能
" W9 X4 l- A8 X+ E$ C2 e* 將字串以","分隔然後比對哪個token最長
" y3 K& o* l  ?*/
% l- ]1 ~; a; U9 G9 _public static void search01(){
' v4 O7 k+ y! o' z/ Q4 p5 L7 ]// BufferedReader lets us read line-by-line
5 j* }2 G; ]- z* i" rReader r = new InputStreamReader( System.in );
( N9 f/ s1 p" p$ K3 CBufferedReader br = new BufferedReader( r );
  `& e- o$ O5 O& T$ ?$ VPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
3 M0 {4 g0 `2 V6 b% l" ]& Jwhile (true) {
String line = br.readLine();
* z* |9 M2 |3 S& O% OString words[] = pattern.split(line);
1 L; o- u. R0 v; G7 w  `, `, x% o// Null line means input is exhausted
if (line==null)
: A# T( T4 q8 Z4 f( M9 S0 u" t  ebreak;
8 ]4 r  M5 U+ C6 W% b// -1 means we haven't found a word yet
7 I: F' m/ E" ?* b- y6 \5 \! @int longest=-1;
# c  f( ]2 S8 l9 Rint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
, G5 u+ N, r9 D% m" }9 \longest = i;
longestLength = words.length();
7 _/ g, b% \  _}
}
System.out.println( "長度最長為:" + words[longest] );
" U# R8 s- K. Y/ V& R& J5 h}
# D5 y  ?0 j1 F8 D' ~# w}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------
% T  }' x/ X& F/ U" P. O0 v8 r+ f
5 l& Y) ?! n$ {5 _# k# G3 T其他的正規語法
+ l- _) ~, b# q7 X  I$ d; a
/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水