关于正则表达式---ZT

Longe

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


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

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
# x) W8 M2 ^) T% U! Y. k5 U
5 }: }" F: _" m& c8 M4 c6 z许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
' _/ Z6 g( \$ G( {随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

正则表达式101
0 y$ f# ~9 H. q) t2 H很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
3 S3 x( t9 G) g8 G8 m& [8 G
第二部分：
----------------------
字符匹配
8 S/ ?' x3 x1 m7 }
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

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

Table A: Character-matching regular expressions
5 L% K6 d" o# b4 N% P8 ]6 o2 C格式说明：
---------------
操作：
: K* b( f3 w3 e解释：
! I; |7 m5 g: r5 v4 v/ p  ?例子：
1 t( b; G; l0 h结果：
----------------
.
Match any one character
. u5 H* w4 _0 R3 l& `grep .ord sample.txt
9 I. _0 {3 D6 U0 x+ WWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
. P8 ^% R6 N: O9 a/ q[ ]
Match 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

$ T2 s4 E4 {* Wgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

( e" u2 l% {- K  s/ ]! \. Y) rgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
( F. X6 F5 f9 P0 {5 g3 ]# s# z
重复操作符
9 T" P: ?8 U1 T. q7 C2 v0 q重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
4 ]# e7 v  v: M% t3 l格式说明：
---------------
操作：
解释：
例子：
, A: J5 I6 c. T. k% Q5 y结果：
* b& `+ R" P+ E' S* ^- I! x0 o. r----------------
?
Match any character one time, if it exists
1 q6 t2 [; l9 W9 |" Cegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
6 @# c) p. E) v, B( M7 e2 T*
) H& k( X+ U9 ], u- U+ F, _# VMatch declared element multiple times, if it exists
egrep “n.*rd” sample.txt
; D$ a3 X; v/ _1 h' e- GWill match “nerd”, “nrd”, “neard”, etc.
5 g5 W2 e$ @8 z7 l! _6 p( R-------------------
' F: Y( C5 m/ N: m. Y+
1 N# |* r1 d$ X( t5 U& m9 V9 i8 c+ j8 }Match declared element one or more times
/ J: e) x" r/ X% f( segrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
$ ~/ V" A# M3 B2 m& f6 b+ x--------------------
3 Q& o8 k& \) h{n}
0 K! i6 W! H- z# NMatch declared element exactly n times
( _9 x/ d# R' k3 I8 Wegrep “[a-z]{2}erd” sample.txt
3 x, H# y; g" y6 j8 b9 S7 c) S+ FWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
# P- ]. g( ]+ c  k1 i# l------------------------
{n,}
. `1 w: j! y, Y% s8 TMatch declared element at least n times
0 [# H, w4 O0 m" i' F! Z1 pegrep “.{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
. _' I' F; p  a2 o; {! _2 s) v/ q+ Pegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
8 Y4 }/ j; e% [$ {) }' t/ W3 [
, k1 ?# k/ U1 @' q3 W第三部分：
----------------
$ h' n& ^( J5 Q" A$ d锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
7 r0 f9 q' x0 t) @
: W- D% e/ W/ k: V( i2 xs/pattern_to_match/pattern_to_substitute/

5 D) D& w; M! P1 }2 b; ~
Table C: Regular expression anchors
-------------
操作
5 A' k% v! q! p# `' S解释
* @- V1 @% a$ Y1 `' \例子
结果
---------------
^
  c* _* [8 Q( |: N: j/ h3 u5 yMatch at the beginning of a line
. t: a' S+ U3 @. c7 js/^/blah /
& S4 O( Y/ r! ^7 M* XInserts “blah “ at the beginning of the line
5 k0 C/ D; r& \+ ^' [( n  h---------------
$
7 I4 O1 v8 m( m0 c2 d4 D* A5 fMatch at the end of a line
& Q& B+ b: {0 ls/$/ blah/
& f0 t, @# h9 l& ?& JInserts “ blah” at the end of the line
0 X7 H9 F8 a  r3 c. J8 e0 f* _---------------
; v0 F9 w* n% a) P, W/ I\<
3 `  i0 ^' N% [6 l' r! gMatch at the beginning of a word
3 w9 H3 N3 j5 ~1 U$ H* ~! is/\Inserts “blah” at the beginning of the word
7 _- q# U* B; N7 D! _3 b
9 n* G: r6 e0 ]6 Z5 z( vegrep “\Matches “blahfield”, etc.
------------------
- B" G! {0 N& k\>
Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
0 q, E- Z/ R& R2 c- q4 v
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
7 d$ p* _  @/ J, u---------------
\b
0 {/ u2 _: J4 MMatch at the beginning or end of a word
egrep “\bblah” sample.txt
' u4 j) i9 u' Q2 O+ YMatches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
egrep “\Bblah” sample.txt
; m6 h6 {4 `  \; `Matches “sublahper”, etc.
. E! f7 i  h9 ]
5 p/ x5 a% t5 W; r/ Y间隔

- ^2 l  o& ~5 W2 Y# r0 `  b( n9 XRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

  m. U. _1 J9 X( Z/ ]8 }1 Oegrep “(n|m)erd” sample.txt
# \  A! \, ~$ \3 K/ K' x; x$ A. C, ^
7 E! a, x" O8 a' H1 e3 }* A间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
/ C% O2 ^% Y8 W& R; \& ?- n8 d1 g
egrep “[nm]erd” sample.txt

2 I/ \) x$ U& R9 d7 b当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
' s1 P1 a4 R: S- U( V- x8 L+ Z
第四部分：
+ g4 H; o- m' E5 d4 a----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
$ x* v4 Z6 V8 |' O
^ (carat)
. (period)
/ L9 o  ?/ K% a* G6 P[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
5 J$ b5 W4 r9 m' v? (question mark)
{ (left curly bracket, or left brace)
; b' |9 [  D) s( @  y# ~\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
+ N+ G- a- Z1 U: p9 W" J8 X" q
9 d6 ?. k7 z: r: P% u你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
7 i8 D2 `1 g/ w在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

1 a0 r1 \$ T: F5 O6 j; L另外一篇文章
----------------------------------------
% d# m- M2 {9 r, X2 b  F" L正则表达式和Java编程语言
- S) }5 I7 y* `" O0 u-----------------------------------------
类和方法
' {% x. |+ n: ^! ?* h
8 _! O/ b) V0 R$ E% B  G下面的类根据正则表达式指定的模式，与字符序列进行匹配。

0 h+ R/ h4 L7 k0 oPattern类

) B1 D2 d3 t3 B8 q  f9 U& kPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

! E+ Z1 b7 J" r$ j' A5 I用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
/ I5 p' h. a; s" m( D3 ]/ t
+ i% t1 f0 ?' j用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

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

8 h0 \7 Q& w. v; O* f0 d/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
- E. \, |( d) F( `3 R4 Eimport java.util.regex.*;
/ R# [6 h( N0 U+ [4 [- E7 |& |
  V4 k) v6 T( r0 wpublic class Splitter {
public static void main(String[] args) throws Exception {
4 q* F6 G3 v% @: @& A+ l// Create a pattern to match breaks
4 ~4 l# I! q3 p+ J3 SPattern p = Pattern.compile("[,\\s]+");
/ v. _( l+ ?  I9 G  i9 E. `$ }// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
$ s* ^& `/ \* M: R! Vfor (int i=0; iSystem.out.println(result);
4 B4 e1 l- {5 k  q* T, n}
7 x' g2 G! M, {7 ~2 ^- ]3 ^- y}
! j4 M  @1 Q, S% b$ w1 \3 j0 D' u
Matcher类
- P; n0 v. M* U+ n' V
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
# b, f7 k, g( N
  {4 t5 [% e! K( Q" _# C3 f$ Pmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

" b: r; U7 u) a9 V8 |9 B7 ~这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
7 z+ r7 ?# ?$ P8 m
1 n  ]! c) q4 z( lappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

- M. K  D  _8 i  e2 |3 J4 V" @6 E例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
* N3 L1 L- Q& O, l# {# K0 J5 [
Regex情景范例
; {5 J4 n' _' A% M: T
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
3 G1 E; l* b/ u% b: N
简单的单词替换
5 l: X0 I: r/ v, O) Z
/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;
, o. d& F% T/ M1 ]- Y0 ~( n
- h' m4 K; E* p8 `public class Replacement {
) q: \; a) F! S* M5 f- j6 Tpublic static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
2 R4 b$ B1 w. b" I3 ~$ S( B$ BPattern p = Pattern.compile("cat");
// Create a matcher with an input string
# C# `* J$ d7 s+ ^( g2 ~' PMatcher m = p.matcher("one cat," +
' v5 ?( V( E8 q1 U     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
/ \& M' O3 l. _+ {$ i8 V// Loop through and create a new String
// with the replacements
while(result) {
+ K# ^# b; @' d+ }7 em.appendReplacement(sb, "dog");
6 w' Y" m: _8 d. w9 i4 D4 zresult = m.find();
0 |6 `. y7 G1 b1 h6 }' R4 h/ U* s}
// Add the last segment of input to
// the new String
m.appendTail(sb);
1 t8 d# R) D# h; d. U9 r/ e+ n5 Z2 USystem.out.println(sb.toString());
3 j0 R: y7 _& k$ l4 s9 D' ~0 p}
}
& K1 T6 o4 Q, G, F/ y1 F
5 t; j+ n+ ~( S6 H6 k9 O- ]电子邮件确认
, l: i7 [  d9 i! p7 i# v7 ~
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
$ N" |& B9 b+ H  n- o* Checks for invalid characters
9 L5 \, K/ G. S' R% o* in email addresses
0 M9 A# O' ?) R*/
public class EmailValidation {
5 `/ v& j4 a$ u3 e2 e' ?& apublic static void main(String[] args)
           throws Exception {
1 J) S6 R# @6 h7 C$ p! y4 P           
String input = "@sun.com";
3 I3 \/ o! h- q4 ~6 j6 s- ~9 v//Checks for email addresses starting with
3 i' R7 ^* y; L//inappropriate symbols like dots or @ signs.
. S- D& y& Y/ o( n; {# E9 F7 ?Pattern p = Pattern.compile("^\\.|^\\@");
: J8 G* K" E' I+ y( m. vMatcher m = p.matcher(input);
% I: u# o" p+ _6 Yif (m.find())
" H# X9 V% l- }' ]System.err.println("Email addresses don't start" +
/ Z% G* E+ K( B# r' O         " with dots or @ signs.");
, \# y, I* Z& f//Checks for email addresses that start with
4 ^  X% k0 R6 L5 Q& r//www. and prints a message if it does.
# t, R$ x4 H! Ap = Pattern.compile("^www\\.");
1 o. M3 W* y$ z$ E- E* nm = p.matcher(input);
' l2 r# H2 {4 x/ ?: N( G  b' lif (m.find()) {
1 D5 y1 W/ U: X" m, P5 NSystem.out.println("Email addresses don't start" +
! o  ?1 V0 h  n) D   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
7 d. s* w6 `8 m) L1 T. [m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
- a, a# E: C" g" U- }" kboolean deletedIllegalChars = false;

while(result) {
deletedIllegalChars = true;
$ \4 B; d4 l; I* o( Xm.appendReplacement(sb, "");
$ _/ g1 `1 p  y, b5 c' e- n; |result = m.find();
}
; H9 u% x+ r. }% C& ~: z" O/ T: I
// Add the last segment of input to the new String
m.appendTail(sb);

input = sb.toString();

5 e. F* E; X* k0 R, [& {if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
$ V6 o& u5 o# m# s: e- Z9 c}
}
}
* n  R0 N+ O$ d, L8 ?
9 u4 Y/ k' R, t9 C从文件中删除控制字符
; e) I% q2 Q: Z/ u3 R; Z  R
/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
; z1 I: }( [3 d% w+ c: p0 `1 z5 `import java.io.*;

9 C1 a- H6 i) J; ipublic class Control {
public static void main(String[] args)
" f$ W* R0 j2 ]0 k  V           throws Exception {
8 z0 \- H# L9 H! `: \+ \           
//Create a file object with the file name
//in the argument:
0 B  o! h, n% z* i  I1 V/ OFile fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
9 J- e. c# J$ j6 [- _FileInputStream fis =
$ ]. }* @( d9 N8 w3 U- g       new FileInputStream(fin);
$ w/ U% i8 z: c6 xFileOutputStream fos =
       new FileOutputStream(fout);

! r, G4 X' P! B; }BufferedReader in = new BufferedReader(
  ^* H, B: X* ~- q1 w     new InputStreamReader(fis));
/ O, w1 L1 ^! U2 A$ a4 ~) z* pBufferedWriter out = new BufferedWriter(
- d6 b- ~  `* i" u3 u     new OutputStreamWriter(fos));
4 z8 t" A" B9 X9 \1 _- q$ \
1 V7 v/ z9 Y3 i// The pattern matches control characters
6 T/ ?% C" o4 s1 V$ VPattern p = Pattern.compile("{cntrl}");
$ ]6 ?! U+ ]9 X0 N, e8 k9 ^' T" TMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
; ~. C$ w4 U  w0 R/ {+ F' Q, r//string.
3 F4 J6 Y' _4 [6 x, @String result = m.replaceAll("");
out.write(result);
out.newLine();
}
- |  F2 J/ ~5 R$ E4 Xin.close();
( ?% l- x  U7 `! ]4 gout.close();
3 ]/ A, v3 N, ]1 d3 h% I" ?1 j6 Y+ `}
}

5 N  m+ j; I7 ]文件查找

6 v7 c  l$ _$ i8 i% o/*
* Prints out the comments found in a .java file.
*/
/ g3 A. o! j& h* v" E; R% Himport java.util.regex.*;
- N$ U  ]% j* `" @( l9 |! n6 Mimport java.io.*;
  I- x( O& T. N) bimport java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
" R% \0 V& c  c7 i2 n% Jpublic static void main(String[] args) throws Exception {
* g$ ?" {. M" K7 `  N// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
& t$ M6 j1 x. v( s& i  _$ R1 j- X6 aFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
  ^3 r6 b! e& I7 _# D$ `3 A" WFileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
0 [1 C* _; g) d+ MByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
6 O/ K/ N$ ^1 h* c' pCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
- R" B1 e% [$ aMatcher m = p.matcher(cb);
5 ^* C  X7 i+ h5 k+ @! ^, Q# L* Rwhile (m.find())
$ |. K* J4 A0 pSystem.out.println("Found comment: "+m.group());
! X& C, \) d! v}
}
( {' k* R; U6 U1 L6 G9 d) y
7 X" b! |+ N/ V6 Y/ ?! a% t结论
4 o# u% n) M; Q  z- w& k现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
# ?0 N$ ~9 [0 @5 R1 N+ P. o! e
9 ?) |& J- y3 mJDK1.4之正規表示式
written by william chen(06/19/2002)

: p" z. ]1 K! @4 Q6 u* P) C& N--------------------------------------------------------------------------------
' V/ F9 c$ u) x3 ^4 `% W8 z' ]9 g
什麼是正規表示式呢(Reqular Expressions)

就是針對檔案、字串，透過一種很特別的表示式來作search與replace
  c% D3 a" x" r% f: X+ g( T
  ^$ G) E6 S6 a- S1 h0 y因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式

) Q4 a; x& T( T3 p* }. g" D3 e我們可以很簡單的用 "s/
0 ^$ l: t* j7 {- B因此jdk1.4提供了一組正規表示式的package供大家使用
- P5 d/ T- C. [6 B
& ~+ d, @( {# F! [5 o若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
9 v5 x! B. i: s: A3 g
& s5 A8 v, p) |6 J剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

( }$ k" c) ^' I* {. g$ {6 b"." 代表任何字元
" k( k$ w% K% m0 D( V( a+ v
# m# s& n2 o8 B# l正規式 原字串 符合之字串
- q4 Q1 K' V) G. ab a
' Q/ m$ ]6 G* u* U' w.. abc ab

0 Q) A  a7 ^& r7 g4 r7 y) h" z$ u"+" 代表一個或以個以上的字元
; H5 r/ V5 Q) R/ C9 a"*" 代表零個或是零個以上的字元
5 a1 U5 y- X& e
正規式 原字串 符合之字串
6 a3 r; K, n) g4 d6 u+ ab ab
/ w" S7 p1 k6 t% @* abc abc

"( )"群組

$ C  ?- r; O) G& }正規式 原字串 符合之字串
+ j  d8 p3 I7 `, c( V(ab)* aabab abab

字元類
4 q  Y& a- j  g! b/ f
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab


簡式
( ?& \, e" }; t( ?# t! y& C) F# B
\d 等於 [0-9] 數字
- L- i5 f" U" p7 p  R\D 等於 [^0-9] 非數字
* |" Y2 f% a0 c& P\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
$ R: p2 I; _9 x: {& K! `8 d\W 等於 [^a-zA-Z_0-9] 非數字與英文字
- `/ O- N) Q, L* b8 n/ X; R5 l/ h
- M* f3 V4 t' i& ^( O$ x4 i每一行的開頭或結尾
/ a- f* T" s! b
: X: Y( [) p  }  J0 p2 w8 c- j  M0 M^ 表示每行的開頭
$ 表示每行的結尾

--------------------------------------------------------------------------------
& P0 E+ C2 z6 z7 j
正規表示式 java.util.regex 相關的類別

5 j- _1 w- }, Z3 i6 a* }Pattern—正規表示式的類別
# I& w9 B5 K* ^0 F( l$ x% ?$ W& `Matcher—經過正規化的結果
% t2 Y2 Y% s+ {" Y$ B. r. APatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
1 A3 [* n9 w. M" S& F4 O1 e
範例1: 將字串中所有符合"<"的字元取代成"lt;"
" ]5 n8 w6 r$ U" e% I) ~! I- v
import java.io.*;
import java.util.regex.*;
/**
+ n/ y" T: c0 g* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
2 H: w7 E% R  A% [Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
& c# J1 x4 a0 t; i" @' C2 X5 Mtry{
while (true) {
String line = br.readLine();
  K2 c2 j) |) p# y! |$ r8 Z0 n// Null line means input is exhausted
- W4 W8 j( v0 z1 B  L' m  V& E9 }7 Lif (line==null)
( \9 M% W8 g6 K+ q* zbreak;
. z: ?- ]1 O) }3 p8 G( ?Matcher a = pattern.matcher(line);
while(a.find()){
9 g3 Y8 x) [, {& HSystem.out.println("搜尋到的字元是" + a.group());
; K* k2 g) w; x6 k: P}
& A! X3 q4 P& X2 t3 F, m. {System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
3 J3 U% r/ l9 P$ r5 g' R}
}catch(Exception ex){ex.printStackTrace();};
0 N; R& x; N' p}

* N0 _  j( H1 J& a範例2:

import java.io.*;
7 E; O3 o: [" Kimport java.util.regex.*;
/**
* 類似StringTokenizer的功能
. f. [6 Q, X/ i* a* 將字串以","分隔然後比對哪個token最長
5 n- ^( _3 [) Q4 r3 A% K*/
public static void search01(){
// BufferedReader lets us read line-by-line
! e6 ~* J  A8 ]0 ?: aReader r = new InputStreamReader( System.in );
: X* e/ Z4 J0 x( W+ EBufferedReader br = new BufferedReader( r );
  P' W+ o$ G' t2 qPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
4 N- {6 a5 b% I: F4 ?. qwhile (true) {
String line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
- P6 z0 g8 ]3 a# ?& N- L6 b) S+ n, }for (int i=0; iSystem.out.println("分段:" + words );
2 z7 a" D6 M7 N; `6 y( bif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
2 D% E6 G9 h6 K: M7 f4 Q9 R}
( {% s/ v7 D: Y" I}
System.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
% `5 R) g9 e0 Y5 Q( f$ w}

3 u- o$ t, r# B6 I--------------------------------------------------------------------------------

' g' p  [; u& C7 s; T! l其他的正規語法

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

一叶

一头雾水