关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
5 t- C) m7 l9 e* N$ A7 F' j2 j
- W& n: }9 I( G; m, j1 Z支持多种平台

+ |+ U; _& t+ j, X
2 H8 Q) @- i) O4 b4 b正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

+ c) a+ w- |: Y许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

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

6 ~5 ?- O% H- q+ M7 i正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
: X' Q: w6 M" y2 x# ]! P; m" A& S----------------------
# n* Y3 A0 h$ |字符匹配

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

& R8 i# q' I5 y  B8 A5 l* p" z每一个表达式都包含需要查找的指令，如表A所示。

8 }6 x* F6 l: W: g: T( {) pTable A: Character-matching regular expressions
2 G  D- s6 }) u, @" g7 F9 }6 [5 D3 Y格式说明：
5 N- l; }* w$ Q- \---------------
1 }$ [6 H: C& `9 j9 y操作：
0 w4 f0 g/ G; W' X- e% K# X' P& }4 o解释：
9 q; ?* L( m- N例子：
3 }) h' u7 b5 e) N/ R8 g. J结果：
# a, f( Z( h! T----------------
5 Y7 H& {( D& a4 c0 r, o7 h.
Match any one character
% l& b8 w/ }0 t3 X( ]# n& M0 H2 fgrep .ord sample.txt
" @* P7 ]/ z- C5 K2 l# z9 ^Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
0 Q' k: Q( ^* ]- RMatch any one character listed between the brackets
grep [cng]ord sample.txt
, Z- T" j6 E. F0 b- i) `Will match only “cord”, “nord”, and “gord”
/ k9 y+ w- i( r1 D* B---------------------
[^ ]
Match any one character not listed between the brackets

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
+ O+ s) u( `! n$ ^5 h0 A
' i$ l" K: P/ ~' |! Ogrep [a-zA-Z]ord sample.txt
, d  U, Y8 O& I: ?& `" t" tWill match “aord”, “bord”, “Aord”, “Bord”, etc.
( W. f  x3 p# C' s% l8 B
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
8 H' V7 j3 d, a* U& O
重复操作符
8 \9 _" X3 W. m. Q6 T: [重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
# f3 C+ n$ u5 l5 j& R+ @; w: I+ x  Q: Q
+ J7 J; V4 z0 o( q1 U- m2 {Table B: Regular expression repetition operators
格式说明：
---------------
操作：
解释：
例子：
结果：
3 B* l7 G3 L& H$ y----------------
?
Match any character one time, if it exists
' {; i$ \; K1 j5 T" b( M) Y" legrep “?erd” sample.txt
0 w" v4 E7 n6 k  `+ {: KWill match “berd”, “herd”, etc. and “erd”
------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
: R2 r! P$ U! R; P-------------------
6 P  \" {! A0 y  S# s6 `* Z+
" o7 f, B  `' p, S: h, xMatch declared element one or more times
& Z1 F6 R/ y* z+ O, |egrep “[n]+erd” sample.txt
" X2 D8 N  |: y2 {  C$ V0 ~Will match “nerd”, “nnerd”, etc., but not “erd”
: {( M! L" y: g. _5 y& i--------------------
{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
6 i3 t, a* r5 I# a3 v  U; ~------------------------
4 R* K8 z6 Z4 l3 u3 ~" |{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
9 W2 o' J! |  Y- V" Q3 z/ j------------------------
{n,N}
: w( _$ Y" @- b! t' i2 Z5 zMatch declared element at least n times, but not more than N times
# ?: y' P0 x. Vegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

9 [# S: T" z% o  y5 A5 J+ Q3 v7 ^第三部分：
----------------
2 k- v* D. Y* x$ G4 E1 g& ?9 j锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

" R0 h* k7 w$ [" m9 H1 }( ts/pattern_to_match/pattern_to_substitute/


; c% r% `: A' {! u' eTable C: Regular expression anchors
-------------
操作
解释
/ i0 M( {/ X* v例子
结果
---------------
6 J" l4 o) m- S, L# ^& j/ N^
+ E- ?& v9 U# o" I' J! O. K$ JMatch at the beginning of a line
- _" Z( p5 _4 T( A( h" P' Q! ^s/^/blah /
Inserts “blah “ at the beginning of the line
& y) i& g( O9 E- {% S---------------
$
0 T6 V$ }8 j5 {3 ^$ g7 V  i% TMatch at the end of a line
3 B$ _2 ?5 L% zs/$/ blah/
& P, w6 B) n7 l) W& _- A) QInserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
: p3 x# H2 n1 N# E9 N1 Y3 V3 w! ?+ Ps/\Inserts “blah” at the beginning of the word
; @9 G4 n9 Z& _: |5 J
egrep “\Matches “blahfield”, etc.
------------------
4 ?: a* @  x& O$ W\>
. Z) u9 l; ]1 F: l3 W  O+ tMatch at the end of a word
9 {' I0 c" a) F7 U( ]" K# N2 hs/\>/blah/
Inserts “blah” at the end of the word
  r; {+ o! R6 h& B& Y+ c
1 u" K* v9 P" {& ~. ~egrep “\>blah” sample.txt
& b0 w( T9 ~# {Matches “soupblah”, etc.
---------------
\b
$ z8 t1 u: o* i% h2 @9 W0 |+ ]Match at the beginning or end of a word
egrep “\bblah” sample.txt
3 C3 r; `; `4 {6 ]Matches “blahcake” and “countblah”
-----------------
" v9 g* X2 }7 u) d+ c\B
Match in the middle of a word
egrep “\Bblah” sample.txt
6 h/ S3 P6 A; ?) ]1 ^# Z! PMatches “sublahper”, etc.
, {( R& e9 P/ m5 W7 \4 f6 b/ h
间隔

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

egrep “(n|m)erd” sample.txt

$ R8 _; L6 T; ^2 o间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
) K- u; \6 P2 _+ Q! X/ U+ v& P
: l' `9 q/ H+ j' `* Y( Z3 a$ yegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
1 `* Q' e; O$ C+ i2 q* K- X8 C----------------
一些保留字符
* E6 T6 S% ]8 hRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
/ r! Q' S& h2 \1 \) w
^ (carat)
! C: W# G2 v5 n# g0 J; |, E. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
6 W3 C9 y7 G  C| (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
( p0 v0 y2 a  j+ s\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
  X( N3 I$ v7 g, E# R' V, e
- s' n& k3 W: \0 b6 Ieregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

- s* q, A/ x+ w8 u% f- z你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
2 X2 |9 g1 J, l  F0 y# B8 r- s
4 \' J* ~- l6 \  r* ]% z总结
& Y, U# c& ]& o) R在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
2 n( p. U) q# e! e  y
9 a- j( S0 H  ]( n4 L( }/ u另外一篇文章
  j  k* @" W4 \/ x----------------------------------------
' t) o5 w! R7 E' i+ x正则表达式和Java编程语言
-----------------------------------------
类和方法

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

Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
7 X% U$ A. \# X* A- Y1 j0 k
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
# ^) o! t% x, O9 n2 L% z# F( `
# f$ o% }  T; p& x! m% h4 ?1 x用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
- \3 s6 }. [' W. z, Y/ b/ R# p
2 [- ]. o  v9 Dsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
/ ^1 O) x% i. ^( \*/
- u2 ]$ u2 n( \0 T& V/ ^import java.util.regex.*;

public class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
7 F2 v; _+ R, X: a* UString[] result =
   p.split("one,two, three four , five");
7 X  A0 |  P- P4 Z9 @for (int i=0; iSystem.out.println(result);
}
& d0 x, F% t% W# M7 q& G0 P}
4 U/ H* @( f/ D/ N+ N5 {
4 ?" j. b6 c2 s$ ~6 ^+ N7 }6 XMatcher类

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

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

) S. G' u: k/ w* r* n( t: x  J; imatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
0 i1 k% V+ c. m9 J+ w+ n. V
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
. p- ^* I$ \3 v" @9 [- g
, v" u7 }+ b4 F+ t# b0 C: n这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
5 G$ B  h/ c5 x6 R7 W, N, l$ |) z9 q
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

8 J5 @0 O! [/ @, P( [CharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
6 [! j- @1 {$ h
Regex情景范例
2 o( u+ h( d- n) `
6 q# m- d7 |+ q2 G( M3 s以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
4 R- }7 a2 i; ?6 Z7 h
简单的单词替换

  q4 q' H4 e$ N9 w+ b0 x5 F" g/*
, Z$ v( a- ]2 y4 e% @( o' j* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
3 ~0 J$ m; H' f% c; simport java.util.regex.*;

0 H3 J- V8 ?" ]9 G' X6 a" e0 apublic class Replacement {
; B# h: y5 A; h5 Z, B0 W7 q) t  hpublic static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
6 V9 v/ b( K/ O1 R# c// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
. M5 ^: `& |6 y% E6 _+ [2 J) n) a& Lboolean result = m.find();
$ F! P$ X( _! q  z# v// Loop through and create a new String
8 N# w4 s% d9 q) P7 n0 [// with the replacements
8 S2 D- D/ {0 [while(result) {
# z/ N' @  |1 |2 rm.appendReplacement(sb, "dog");
result = m.find();
}
, Z5 k/ z! H; A; R3 D/ l// Add the last segment of input to
// the new String
m.appendTail(sb);
0 E; {; j. A; B7 }' F7 @: c! S4 d" BSystem.out.println(sb.toString());
}
% Q- R  `( G8 @; e( x/ V9 e# L( w$ L}

3 f4 X; l' b8 M  l: A+ |" {电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
  C8 G6 l; z6 t8 p( Q
/*
* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
2 I0 B" e8 L0 c& J" @5 l$ v7 M+ gpublic static void main(String[] args)
: I( _& s2 n" @1 K/ z4 F% x           throws Exception {
           
String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
. N4 M9 X# O$ i6 ?0 Q1 ~7 _Pattern p = Pattern.compile("^\\.|^\\@");
3 ?: u9 u! z4 J' S7 o$ |Matcher m = p.matcher(input);
$ M6 Q9 Q' A" A# Y( Fif (m.find())
2 o" [, D7 m8 E$ ISystem.err.println("Email addresses don't start" +
0 R) Z) {* Z! q* r) M         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
6 M, n( C( R- X: Fp = Pattern.compile("^www\\.");
m = p.matcher(input);
+ X& h- ]  n9 D# `* zif (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
$ n3 v6 P. P0 i5 I9 g% F% m}
, H0 G1 e; ]: }, I# v- Jp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
% A2 z1 u4 m, g9 y0 y5 A! @m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
deletedIllegalChars = true;
8 @5 F& b  m' [3 ^m.appendReplacement(sb, "");
5 {5 U" G+ x) `! J9 r) e) ~result = m.find();
}

5 T. ^8 i: F' l/ D8 M! R  _' V// Add the last segment of input to the new String
( \- s+ p1 O4 n; b! u! ]; l9 nm.appendTail(sb);
$ w' E7 m1 ~/ Q: X& ~6 e
5 ]" d( Q2 t) X  }input = sb.toString();

if (deletedIllegalChars) {
- n6 ]: d, j9 i2 q* JSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
+ u; u7 \( {+ d}
}

从文件中删除控制字符
% R* F5 z7 l2 R0 L
/* This class removes control characters from a named
* file.
*/
9 S+ [, U. W) ]; e' A# x/ m3 Jimport java.util.regex.*;
* k" S% @& \7 w% E) O/ Eimport java.io.*;

public class Control {
0 d( c' O& u7 `, F0 jpublic static void main(String[] args)
           throws Exception {
           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
  G. O3 A) i; @//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
$ h# A; e: Q6 V! YFileOutputStream fos =
2 `4 g+ @) }- H$ T8 }$ H' Y       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
) H- L% b" ~' {( w$ e# E     new InputStreamReader(fis));
8 z  `+ w# V6 Q3 M7 u+ o) h( x3 zBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
( ?6 m# M( ]+ m& Y( r0 V+ I2 M0 `4 M
// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
: }4 n" @+ D- X$ TMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
: s( Q  y( B% G7 Km.reset(aLine);
  Z$ p% t6 W0 y6 z( n//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
}
3 ~& s4 n4 i3 A5 win.close();
out.close();
}
}

文件查找
% k& ^& q) o7 \# @- f5 t: y0 G2 ^* i
/*
/ {: `! D- }% }- \) X* Prints out the comments found in a .java file.
8 _  p. b: p2 u' N- r3 ]5 `' k*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
/ U- }2 _, l+ J6 p9 v0 Vimport java.nio.charset.*;
import java.nio.channels.*;

' k7 v( Q6 v/ g8 d# p. S9 n8 Fpublic class CharBufferExample {
+ _: l6 X4 Q% G* h  [3 A* Gpublic static void main(String[] args) throws Exception {
, [  x& N7 ?! p2 n4 \# o, F8 n// Create a pattern to match comments
8 H5 N. ^! k; f+ E+ ]* |Pattern p =
: O& |9 U) y, SPattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
! J' H6 N" X; Y# x* fFile f = new File("Replacement.java");
3 `, [: S+ e- o7 j3 b' g  q3 @5 \FileInputStream fis = new FileInputStream(f);
, F# ]0 z, ~2 X- [  F' sFileChannel fc = fis.getChannel();
- U3 H' h6 d& ~) H! `& v/ C: }) I: j
4 s/ @8 O. f! q9 x& U. D// Get a CharBuffer from the source file
$ _7 w; B, ]9 U- H3 IByteBuffer bb =
& p. H2 ?  h  H5 Hfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
  h( k" O6 ?. t9 D5 Y* U& QCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
  A& u0 N: P, n4 i" }" ]3 ]$ eCharBuffer cb = cd.decode(bb);
6 a  e9 [# K" y% m+ \; L
2 ?9 t4 j! b: m% a% \( Y// Run some matches
# N8 _$ _4 o" ~0 M' HMatcher m = p.matcher(cb);
$ o6 ]& R0 s0 k& i. twhile (m.find())
System.out.println("Found comment: "+m.group());
! q) G  v" {* F; q* S* l! E7 V}
9 Q; O( [' J, l3 b& X& u5 q% U}
$ f' S' X% d% b) m" @$ p$ S; }
9 I0 K# S1 O$ c* {7 u结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
/ r6 K# [% N; W. x0 w$ j! W( H0 v
! T" O1 Y* f, j3 `" SJDK1.4之正規表示式
written by william chen(06/19/2002)
6 o1 P3 A) U- o4 `) t: W# U
  F, U9 c. y1 {, b--------------------------------------------------------------------------------

- p4 R3 Q+ Q9 _( d2 j8 F什麼是正規表示式呢(Reqular Expressions)
. m8 A& Z( m& g0 P$ W8 t
* O& H  i5 A: Z5 K& @' F2 ]就是針對檔案、字串，透過一種很特別的表示式來作search與replace
7 `8 K  L' v: z* Z3 W0 z& _# C
因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

+ H1 `. S% k: \所以發展出一種特殊的命令叫做正規表示式
# P8 a3 q+ h4 Z" Y% G- h
7 b* ]3 G$ `) q; l" ^0 M5 E我們可以很簡單的用 "s/
- C: Y) \- I( x  _# v5 U" z& H因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
4 c2 A4 W5 t; [) `' h: ^* }; [' \
7 X, h, ~* w/ f+ \2 c7 r1 W剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
3 {' ^4 R! U) i" D: Q* v, y# M
"." 代表任何字元
/ f' r: C  j4 ?+ o* C) C
1 U* d+ j6 ~9 v  M+ f& b: l" ~1 G8 `0 A正規式 原字串 符合之字串
4 G/ l8 i' k& Q) o' l. ab a
.. abc ab

"+" 代表一個或以個以上的字元
- U; o% Z- n) _2 H* l; a- N" k"*" 代表零個或是零個以上的字元
# N1 y1 T. E5 q0 u. h0 Z8 ?
. q- M7 k& m1 W正規式 原字串 符合之字串
+ ab ab
* abc abc
, Q' W3 \& ]2 V# W
"( )"群組

% h4 C, H6 Y" i. F正規式 原字串 符合之字串
2 d& B8 p, H8 U$ o. j" m% H% ?(ab)* aabab abab
9 Q6 }5 Y$ \$ v8 \( D
9 M1 Z3 K7 O- {. x, j& i  Y字元類

正規式 原字串 符合之字串
7 l1 R* `- E$ N5 {7 C[a-dA-D0-9]* abczA0 abcA0
" f% K" s' x$ v[^a-d]* abe0 e0
[a-d]* abcdefgh abab
, @, H% H) Q$ `  f' d$ u
6 C1 H0 R7 M- ]) P6 T! w: U
簡式
" f/ h, a: k# ^% ~" W
) _4 D; `3 x9 ?" n8 ~$ M$ R\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
* K$ @: x) f* O\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
- E1 b7 V$ k" t/ n6 A6 G, v\W 等於 [^a-zA-Z_0-9] 非數字與英文字
1 v' Z+ `6 C: |5 e, |
% f" U) d3 \# p% @: L每一行的開頭或結尾
4 q/ e7 \: e$ Y; h
- ~! K! a0 f4 m6 j+ w^ 表示每行的開頭
# ~. N5 s5 t  v4 ?" f1 Z$ 表示每行的結尾

--------------------------------------------------------------------------------
7 d! e- c+ l4 K# x
* q/ j& y' x( T5 |3 J正規表示式 java.util.regex 相關的類別
+ C( P! t0 x7 Q( o1 u4 j4 {
$ O& i6 I. h/ O, h, GPattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
6 ?/ p' b1 n4 r' e8 r# x
範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
) J# N4 I# K* A5 Qimport java.util.regex.*;
, r$ J. ]% B* [/**
* 將字串中所有符合"<"的字元取代成"lt;"
/ ]3 R6 ]0 L: w' H*/
public static void replace01(){
7 M5 n. u# {) @  m5 r// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
' S4 I* f2 |0 m# K+ L0 ], p. rBufferedReader br = new BufferedReader( r );
5 @. N& Q8 a9 J* v" @  K( q! [  MPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
% A, x& M4 Y$ a& y- g/ B: A& {try{
while (true) {
String line = br.readLine();
% }. o1 q& W; s$ t) R- A// Null line means input is exhausted
if (line==null)
4 D& J& a' a2 jbreak;
Matcher a = pattern.matcher(line);
! W" ~5 z" g9 i" g, c4 Zwhile(a.find()){
8 h, K8 H/ M. m0 H" X& OSystem.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
" N2 ^# k) h& w  u* Y5 [4 k2 e}catch(Exception ex){ex.printStackTrace();};
/ Y8 {, G/ p$ `9 }& K/ y/ G}

範例2:

: d8 \: a8 M2 z. {$ [, vimport java.io.*;
import java.util.regex.*;
9 }+ N5 f9 T) m/**
* 類似StringTokenizer的功能
/ X4 W. Z& D: L1 k5 M+ A+ j* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
. p  X3 X" P- `// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
4 u5 S4 B1 s/ N0 S4 {7 O% N, rPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
- m$ P, m3 v+ \8 ^/ t, u% ]try{
while (true) {
String line = br.readLine();
, g! i( \% u, JString words[] = pattern.split(line);
7 f0 ^+ _% s/ ^# ?9 h// Null line means input is exhausted
! p) z  o6 I& m4 Vif (line==null)
! a& j' k: C7 r+ U" q( O( R/ e4 {break;
// -1 means we haven't found a word yet
) T- B. V8 d0 v$ W6 Rint longest=-1;
/ O$ H+ S! }) N* D5 I- c4 G! z3 ]int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
& {" v+ f( ~. x; [2 pif (words.length() > longestLength) {
' L, f+ b; v* ~4 ~. zlongest = i;
2 N4 K  B* g/ t* g% X4 `longestLength = words.length();
0 n  @3 v9 Y5 ~( e' Y" ?; ?}
' p& w3 x" N) W2 o7 H& a}
System.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
3 Z1 f6 ^$ m' O# m% b+ d}
9 u# q; t' {; n# O* \" f! U5 a
& d' `% ], N6 _& I--------------------------------------------------------------------------------
$ @" X1 e: N9 b( i! }
* [2 e. Y$ k4 ^3 c/ j其他的正規語法

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

一叶

一头雾水