关于正则表达式---ZT

Longe

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

支持多种平台
* c( F( y* \. l. p$ ?: v' O

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

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

9 b) A6 B% E  {9 d, P6 r- X6 }许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
( e9 v/ K) R. T/ U3 T! M4 \
比你想象的还要普通
- [% l8 p" c/ S5 ?* S随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
" U7 a; \' T! E; j2 a0 Y% Z
3 ], P4 `7 j9 p正则表达式101
- n6 T; _4 A0 Z% z* H很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
----------------------
+ H9 U" C# e( T) k; c+ }& N字符匹配
) r4 u, l! s( M$ {$ Y% L
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
" d5 a6 e# e0 t
每一个表达式都包含需要查找的指令，如表A所示。
" K* |+ b5 T2 [: v1 j! F. d
: F( o8 t# M' D- @, d* yTable A: Character-matching regular expressions
- f: K0 @+ N% a0 t( |, w格式说明：
& q( |/ X" C4 H! O% O---------------
操作：
& l# N6 S; \8 q: _6 g" I解释：
例子：
& Z/ d' ~9 d/ Y4 t结果：
----------------
.
1 K( {" }) p, z$ e6 sMatch any one character
3 _! P0 O* @) w, ?4 e9 Qgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
# ]9 E5 k4 b; [' [, o& w-----------------
[ ]
8 F& C2 u8 K/ k% L+ X5 c6 kMatch any one character listed between the brackets
grep [cng]ord sample.txt
) Z3 ^# m8 ^1 C1 XWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
/ v) b& ?" O) S% g6 lMatch any one character not listed between the brackets

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
7 T1 P! i7 p0 f; r
1 m+ Q, ^) p2 `! s  `* k5 T0 S! ~0 igrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
3 {8 E" c. s$ |2 v- L
7 ~: Y. e( k7 G* {6 T5 ngrep [^0-9]ord sample.txt
5 n5 O) u# X1 DWill match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
# [8 Y4 L. h( `. d7 ?3 x---------------
( @" C+ i' v1 r( ]0 ^操作：
解释：
例子：
结果：
7 H' S7 K8 m& N----------------
( Q( k+ k4 r: h; y?
Match any character one time, if it exists
egrep “?erd” sample.txt
( Z0 G# e# A6 O# \: x+ r* ZWill match “berd”, “herd”, etc. and “erd”
------------------
*
4 b. G' n& ^2 i* X  M+ O# ^Match declared element multiple times, if it exists
# N( Z; K$ H3 C- U2 Y! \2 wegrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
  W  J! x9 k0 V' W6 g9 V2 d2 {7 j-------------------
1 y0 ~+ r  C. w' Y5 |+
Match declared element one or more times
* {. X) B# _4 h3 ]2 R' ]egrep “[n]+erd” sample.txt
$ e6 Y' z! [- H0 N* K. F8 G2 JWill match “nerd”, “nnerd”, etc., but not “erd”
- i! w/ S+ X# J& m. J: O--------------------
. {$ Z4 L8 n; n" C+ p{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.
2 U+ k; ^7 H: [------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
  o: p$ t4 O. C: `( ~0 |- y------------------------
{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
% w7 w7 e8 a% g3 g7 o: sWill match “nerd” and “neerd”
- u0 s  o( z5 z8 f; s
9 W6 A1 A2 d, W8 h& v& ]第三部分：
5 m9 G( p4 n, D+ A3 ^----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
0 F& {7 W: Y& k; B
( ?3 g. ~2 P' n# As/pattern_to_match/pattern_to_substitute/
6 Q+ e; i4 l( f, `5 [
0 o  b& R9 @( e: w3 S2 A
Table C: Regular expression anchors
7 b* q2 ^+ p& p- ~& s. _9 X-------------
/ x0 d5 I! V! U" q4 ]- Z操作
解释
例子
5 M7 i* U5 H! Z结果
4 v2 o" N9 a. s  e" T2 f) `---------------
^
$ |8 U: P  W" ^  u, L* bMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
/ z  g/ g9 f( @$ {1 d9 V---------------
* v# C" m3 I7 D* M: Q$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
& h" x3 {7 k6 ^s/\Inserts “blah” at the beginning of the word
( u& Z! K9 c/ B$ K
egrep “\Matches “blahfield”, etc.
------------------
\>
Match at the end of a word
0 ^3 l; G9 x$ u9 [+ is/\>/blah/
Inserts “blah” at the end of the word
6 e! a; Z1 P: [. ~5 r
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
% i0 _$ g& f2 K0 S/ [3 Y6 A5 c" U\b
Match at the beginning or end of a word
9 [: i5 W* f8 begrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
( ~9 ?' o- N: z  ^( j-----------------
# R+ V& }# Z4 q\B
Match in the middle of a word
& ]+ O/ G, M/ G2 `1 l5 B8 @egrep “\Bblah” sample.txt
+ i  L; a# I9 Z$ T8 Y$ w" S$ UMatches “sublahper”, etc.

间隔

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

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

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

egrep “[nm]erd” sample.txt

6 i+ ^( w' i9 Z" Z( y5 l当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
. U$ I! ^; G7 N
第四部分：
4 e# Y# K  j; P8 Z& M$ q+ {" v; n" m----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

. S# L$ ?5 B9 {% R! r^ (carat)
' \  y+ b8 k2 K. f) a1 e3 c. (period)
[ (left bracket}
0 C( Y5 ?* i- Z6 O" g$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
  e) T0 f$ d' Z) M' F. g( \7 a4 K4 T| (pipe)
% W& N1 n# z% b# _7 D* (asterisk)
+ (plus symbol)
? (question mark)
- \" g( B7 c  E8 ~: N{ (left curly bracket, or left brace)
" p7 c# c8 O% g\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
4 B; |) h7 m4 |/ }
1 |% }- l! N$ k" ieregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
2 T$ p* j3 n4 _0 v
! i4 B( \; C) d1 G5 J% ]9 Y你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
/ F* c$ |  U8 l9 O6 r
# G3 j# p1 @* ]# D总结
( ?3 }7 z, Q& r, Q! A/ x* {9 {在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
0 ~( [- r, v7 q0 _% k
另外一篇文章
' _0 T- n4 |5 r. T+ S0 Y: e: `  p----------------------------------------
+ y) ^3 A! S( X" u2 I1 b0 t6 n正则表达式和Java编程语言
8 b# V  [# Q: U: E3 T# R- f! \. O-----------------------------------------
0 _6 }+ O" a* A* k  w% c类和方法

6 M" j# C+ E# O! \2 Z: a& D下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
  @  i5 ~: f: J
, f: \6 ?, _$ q2 N6 Y. l. oPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

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

! e: k5 o1 n  \用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
" y- C1 S5 M+ q8 L
/ s. d+ W1 z9 S; asplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

3 J! v& C7 i0 j/ a/ Y; Z/*
% P( h! [; [; [) g3 j* 用split对以逗号和/或空格分隔的输入字符串进行切分。
) f. r) Z7 ^% X! n+ [  h*/
import java.util.regex.*;
  `- L* ^9 f4 X1 C
public class Splitter {
3 R! M; Q& @8 T# ]' X$ hpublic static void main(String[] args) throws Exception {
! F9 d* `' s4 x// Create a pattern to match breaks
! F7 |# o! Q+ U/ U8 DPattern p = Pattern.compile("[,\\s]+");
% S3 w" V9 I. ~8 {* U// Split input with the pattern
/ s0 ~2 M5 h5 |0 C  O5 Q, IString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
2 ~6 I) F, x1 H( \2 `, v* Z6 k}

6 y, \& ]& m  {) B) d) a6 U- Z+ ~Matcher类
" U8 n" x) }% e: s3 x' |
" S" H3 m) B+ yMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
/ E& Z1 M1 }1 w& s: s9 m- c8 R
2 R. O$ `4 a3 \/ Q9 @$ `% o通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
+ g; I7 X8 [' x+ h$ @. [) o* k" B: f
( t0 R$ q* [6 S3 c( ymatches方法试图根据此模式，对整个输入序列进行匹配。
8 e- F2 [# j+ A% N- D# P" J4 o( h- glookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
$ x: d- C  o6 d! Y) e; V( \6 Ofind方法将扫描输入序列，寻找下一个与模式匹配的地方。
: h0 E" W0 e3 b+ ]; m) F3 n2 \- Z
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

/ |' y, P& A' [9 q& E3 j& h这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
1 r$ K% w* U2 W# k4 y
' d$ n6 c( X& e3 KappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
9 B* @& S& V0 Y" Y) J3 ~
) ]0 M5 U8 t( ^$ R1 N3 F例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
( i6 g7 p8 o7 v8 m9 j& f
CharSequence接口
  A" ]# B( Y  p. D& H2 Q
6 u6 X1 j0 B5 Q, lCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
# K, `2 v9 l6 g# z" L: t
' b8 S7 _- u9 x& N$ m7 v. IRegex情景范例
* k7 P4 O& q: ?$ h. @; j
% Y% P* D- _# c( u以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
! Q9 Y" Z4 J& D7 c6 U; }
简单的单词替换
( G' X) v7 C  d0 e
/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;

public class Replacement {
+ D/ J- ?8 H% i  h7 x3 `public static void main(String[] args)
& A" {3 [+ |! b* J* L4 J0 V1 I$ w       throws Exception {
// Create a pattern to match cat
1 ?+ t3 |3 t4 cPattern p = Pattern.compile("cat");
& d, i) x5 x/ p; O8 ~) P5 L5 q// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
! l% o3 N2 f& P8 t7 U& W% F     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
* c7 b  i, v9 H' c1 M// Loop through and create a new String
// with the replacements
: B. G/ @! R6 y) m" {while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
' c7 G9 Z! ]) qm.appendTail(sb);
( ]# c( s, o! [1 b8 O" VSystem.out.println(sb.toString());
" X% B' d  c3 E* Z2 `}
}

# t( v! i8 J; T9 D; p( m( k' L电子邮件确认
) A9 r7 T. F/ }! Y; M$ i* D- f1 y
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
, }- M  v# L- ^- e
  v% Z( d; c4 Z* l/*
* Checks for invalid characters
* in email addresses
) d5 {" ]* ?8 _*/
public class EmailValidation {
( c# `0 R. D+ |" npublic static void main(String[] args)
           throws Exception {
1 t) g, j8 P! I" w% s9 W( V           
String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
# J) m) Y9 A4 N3 [8 U+ t* R2 _( D         " with dots or @ signs.");
6 D3 I  W6 u. w% Z8 t8 O//Checks for email addresses that start with
7 Z  F- q! }! X$ f/ z//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
  q) j- K* H- v# Mif (m.find()) {
System.out.println("Email addresses don't start" +
6 m1 _4 ^7 ^+ C" P$ G' D4 C2 R   " with \"www.\", only web pages do.");
7 x5 A' X! w2 \; B2 A: ~$ s}
3 A) t% J+ M* q9 ]  Pp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
1 L0 P& X5 K5 |8 d/ \  H1 R% dm = p.matcher(input);
! H( M0 h* d) B0 I/ X8 UStringBuffer sb = new StringBuffer();
" [4 g+ Q  y( E! g) Mboolean result = m.find();
, c6 G& T0 {; `boolean deletedIllegalChars = false;
) m1 c& _$ E, a, m# z& }, h
while(result) {
deletedIllegalChars = true;
4 J$ M7 ?, }; t+ A. bm.appendReplacement(sb, "");
result = m.find();
1 H2 A( B+ l6 z1 ~}

// Add the last segment of input to the new String
3 Y4 @' m! E8 P7 am.appendTail(sb);
. J, V0 }  a3 m
0 w0 T) i$ r4 t# Y1 m5 T- s9 Einput = sb.toString();

& S  F9 `) \7 ~+ @( Zif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
6 A# q9 w/ r  A}
5 H8 N6 u/ z7 T}
}

1 q0 m# F) ]% |7 j( S8 i& {  f0 i从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
3 D+ h# p; d" R# x! {import java.util.regex.*;
/ G% x& f5 c+ Z& ximport java.io.*;

public class Control {
public static void main(String[] args)
- I* c: @6 s6 r           throws Exception {
) E4 l) Y1 I- W' |+ k% ~) k. Y  a           
//Create a file object with the file name
, J: U$ N- @+ N) z0 F//in the argument:
8 z0 L) _+ I& yFile fin = new File("fileName1");
File fout = new File("fileName2");
/ R9 v, ^/ r3 g$ X. l% B% I! ~  L! e//Open and input and output stream
0 P3 S% v' @7 M  B0 q2 oFileInputStream fis =
       new FileInputStream(fin);
$ H8 M9 `" g' [' B' HFileOutputStream fos =
4 q; E; c+ {* u       new FileOutputStream(fout);

) q5 V/ z2 P2 k. rBufferedReader in = new BufferedReader(
" Z2 V4 j8 ^& |4 ^/ r+ |     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

! \$ t: o( p: B, |" d// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
% N* ]2 e# R4 o3 B2 zMatcher m = p.matcher("");
; I, g) i" Q' ?! _# BString aLine = null;
- L8 _6 j1 }( _# P. c3 Ewhile((aLine = in.readLine()) != null) {
6 A2 W& b- N6 z+ @m.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
}
8 \1 y3 x9 U, @: S" @; G: l) ain.close();
out.close();
}
+ Q* l3 u# a, r8 y: j2 w+ F" g}

) r- F2 |. R+ ^9 \1 d文件查找
5 ~1 t9 t/ ]/ |- A' C/ w) I
/*
* Prints out the comments found in a .java file.
*/
7 e7 k; \, t2 y7 W6 `4 Zimport java.util.regex.*;
, N% H5 |/ O+ K* l* p4 f4 Uimport java.io.*;
& }1 L6 n7 U2 Z9 T, o4 e# C( x9 rimport java.nio.*;
" [9 M# J3 T# N3 i) Ximport java.nio.charset.*;
: `0 _. U0 w( |+ ?! A1 B; ~* Yimport java.nio.channels.*;

public class CharBufferExample {
2 {) g: ?5 t3 R& ipublic static void main(String[] args) throws Exception {
! ]4 B" e# i" k' P// Create a pattern to match comments
Pattern p =
0 r* o* C! q( ?" O- h7 ~Pattern.compile("//.*$", Pattern.MULTILINE);

7 S, u; D* W- `( ^: a* M// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
& }8 k; u) c! F4 b6 rFileChannel fc = fis.getChannel();

- @+ g5 g; R% n7 H" n// Get a CharBuffer from the source file
ByteBuffer bb =
. w$ t0 }0 D' `' n" [fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
+ o  k$ Q0 k5 X$ DCharBuffer cb = cd.decode(bb);

  u0 S7 y: H* z! ?$ y, q// Run some matches
+ z, m" `: H" l; C' M% K0 i  FMatcher m = p.matcher(cb);
while (m.find())
* ^" U6 J" g9 [) N3 g+ Y  NSystem.out.println("Found comment: "+m.group());
5 {; r, r6 {. V* a}
2 p# n3 y2 M5 E4 c% V}
. s4 \/ Q" L8 v% |
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
. s5 W7 S# u1 ]2 u  ]
: K' |" F. a# C, NJDK1.4之正規表示式
. ?! z4 a. j1 e5 v+ W, I7 i; Dwritten by william chen(06/19/2002)

--------------------------------------------------------------------------------
( k) i; m' f! r- r% |$ T0 o/ F
什麼是正規表示式呢(Reqular Expressions)

就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
# t; a. }; d- N9 P4 C
所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
9 S. |. @/ f7 Z% O% S: W因此jdk1.4提供了一組正規表示式的package供大家使用
3 \* o, _! s9 o6 v5 d' s
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
. L7 n/ U2 j) g; N! u
剛剛列出的一串符號" s/
7 Q8 J4 M- _" e) S9 Z( Q適用於j2sdk1.4的正規語法
6 A" n4 z5 n" w! o+ M
/ |, N6 `; G3 G2 \/ ~- n/ ~"." 代表任何字元
& Y8 ]+ B! j5 ^: |, G
正規式 原字串 符合之字串
  s1 i) f7 M( R) ?/ q& F/ ?. ab a
.. abc ab
$ z/ j# ~& A! I. Q9 x
# T0 L$ Q) L6 N8 ~& N' q0 y) o"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

/ v4 w5 Y7 o" a) K: |  Z正規式 原字串 符合之字串
+ ab ab
& y$ f- B8 j/ h; l* abc abc
, E6 l9 w4 r+ c8 b1 H" W
"( )"群組
$ g" S% L5 K2 r# c2 {2 e* B& x
( |2 Z/ M* Z; \% Y* c正規式 原字串 符合之字串
(ab)* aabab abab
8 ~1 T4 ?/ J( D1 S  s, p+ }
4 H+ d4 o2 i% {8 H4 E  [  _字元類
8 }. e( d9 R5 _; L+ u- P6 O! s
9 ^  q6 n+ o* h5 i) _- B, M正規式 原字串 符合之字串
1 V7 p* |2 i$ ~2 C[a-dA-D0-9]* abczA0 abcA0
- r0 w: }: H4 B7 c2 G( I[^a-d]* abe0 e0
[a-d]* abcdefgh abab
/ z6 `, P. b' o- L5 ?' p
3 u. ?' F0 W0 r1 f: E- a
簡式

. J( A) D& q) s. H9 s5 U\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
5 w8 {& ]- k. C, r9 F\S 等於 [^ \t\n\x0B\f\r] 非空白字元
( g8 f/ `4 v  N" u; e6 e4 n\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾
2 A+ L# v% u: @0 v, Q* x4 [
& j  r9 @9 `! Y- e^ 表示每行的開頭
$ 表示每行的結尾

' y0 I3 y4 A5 m& e--------------------------------------------------------------------------------
- U5 Y4 w! d. T* Z8 R  k+ E3 a
, F3 u# ]* \& v5 l5 l% N  D7 T4 c正規表示式 java.util.regex 相關的類別

* l, z/ Y7 p' U% H% b. RPattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
- g) O: z! r$ r5 B& W' [import java.util.regex.*;
/**
& K% E3 K6 c  K/ `' b$ ]2 c* L* 將字串中所有符合"<"的字元取代成"lt;"
( p, n# ?  L# j; ^) n2 ~*/
public static void replace01(){
; \6 A; }# r# }// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
9 s5 u* C8 O6 M6 t3 w7 aPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
5 }- y: P1 \$ W. t- A6 ?while (true) {
String line = br.readLine();
// Null line means input is exhausted
if (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
* C; r8 r- m  g/ ]6 P" b}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
  q$ m2 J, v4 Z9 L- b% Y}catch(Exception ex){ex.printStackTrace();};
}

範例2:

import java.io.*;
! C$ X% G) K0 y5 K( pimport java.util.regex.*;
/**
8 U1 O8 S1 c# V: E* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
/ V7 |% s7 \) \' O5 k! m( j0 H*/
public static void search01(){
0 h( L' J( N% @/ J9 p6 x// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
1 ]8 M: p( V( [, o3 r0 `3 DPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
+ h( @2 `# o% ?try{
while (true) {
; U3 d( R$ M, [" w( T; |String line = br.readLine();
String words[] = pattern.split(line);
3 D! Q" ^! Q  g) r. e: P9 `// Null line means input is exhausted
: O5 J& Q! R* W) k+ q7 pif (line==null)
break;
3 c, }9 i4 p. u. n9 P2 h' y// -1 means we haven't found a word yet
5 r1 N) A# {0 C; C# g! r6 hint longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
: |: u+ Q% v* \8 E; v4 Gif (words.length() > longestLength) {
- U' D( u$ L9 K: K2 N* K( J  B" r' Elongest = i;
longestLength = words.length();
! U/ @0 c2 \" z  Y* M1 ~" L0 x2 P}
}
System.out.println( "長度最長為:" + words[longest] );
* k& R- y3 b  F6 U}
}catch(Exception ex){ex.printStackTrace();};
}
% f; N; @: j0 \) w4 ]+ ?
1 N) M7 ?& o" M8 e: |1 M7 j$ S--------------------------------------------------------------------------------

其他的正規語法

/^\s* # 忽略每行開始的空白字元
6 ~8 m2 ~' j7 i$ [$ u(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水