关于正则表达式---ZT

Longe

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

支持多种平台
; Z0 h$ S" b' r3 w; {. j3 v

正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
( z& y% I7 ?. D9 {$ Y- A# K
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
5 A% w# E8 C; Y1 u& }! `
; u9 A8 M, a9 [! Y% y许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

$ N6 y/ l9 q# z9 p( Y9 m/ w7 W比你想象的还要普通
0 K+ e$ z2 f0 C随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

正则表达式101
% W3 {2 V+ X4 X! G7 [4 ]( C很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

/ r+ V: q' E1 J1 U4 |" s( O第二部分：
----------------------
: H2 w  f6 J$ O! s字符匹配
( ^0 W+ U7 }1 Y+ a
& K( v0 n  @3 B" T1 k& ^5 L  m4 {/ \正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

4 A. D% a/ T$ C4 M& K$ [每一个表达式都包含需要查找的指令，如表A所示。
# t, i' S7 |/ |6 c. c
Table A: Character-matching regular expressions
2 E5 h# n3 M  E& ], I0 d格式说明：
---------------
操作：
" T( }) G5 |& V/ Q4 {$ N解释：
例子：
& d; `/ \' ^% p" m5 W结果：
----------------
; n4 _. K  G+ i; }4 J: b.
, f8 \/ u) i! R7 A5 F0 oMatch any one character
grep .ord sample.txt
+ I6 m6 A7 K5 @+ a1 t! ]Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
9 y2 K/ X2 ^0 q# `% ]( |! z) p-----------------
; G5 h- _3 z# T# s! e1 f/ Q% N[ ]
" h- D& N7 m1 V& ^$ C1 MMatch any one character listed between the brackets
! C: f& D* w6 N& c' h  o7 ogrep [cng]ord sample.txt
2 b2 D: k* k7 w3 _- o( ~& T. e- w8 T3 x+ FWill match only “cord”, “nord”, and “gord”
---------------------
6 g  W8 ]# ~$ z" d* F8 u5 k6 Z[^ ]
8 b0 D6 L" s5 c( o3 N% {. Z! zMatch any one character not listed between the brackets
0 R) c& [8 X$ c. D& @5 f2 I
grep [^cn]ord sample.txt
/ O6 ?, E' b5 d* |6 ^* WWill match “lord”, “2ord”, etc. but not “cord” or “nord”
" I6 T$ M  x) k1 [8 z. \( D4 W$ f" c, P
9 q5 L$ l8 A+ C% Ngrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

6 x, f) ?5 H# w( R1 k: ]grep [^0-9]ord sample.txt
) b& X4 E% U* O% I0 }1 h# S5 R* z% tWill match “Aord”, “aord”, etc. but not “2ord”, etc.
+ ^" G  X8 u1 Y5 X2 G) }! E
% g5 D: _2 h" L" }# P. U0 x重复操作符
3 N7 H6 s0 ?! |7 B+ |$ Z重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

! w7 `6 M1 w( ~9 XTable B: Regular expression repetition operators
格式说明：
' [2 G5 g2 a5 ]% j* S: |---------------
' @* G& w2 r, r$ I操作：
解释：
. B0 a0 u3 E( |5 j8 ]0 p8 ^例子：
结果：
  j! Z4 q0 j6 Y----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
5 a6 L+ H) q7 j% R------------------
4 B% t  a; d8 w% h*
  R8 u1 j7 D* CMatch declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
* T4 s1 w8 }0 V7 d& ~) _& h$ Y4 V7 X-------------------
& e# S0 h5 F; b. I6 O% H( U+
Match declared element one or more times
egrep “[n]+erd” sample.txt
% i6 w& V- W, W. s( q2 R1 D- GWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
  t. q$ Y# {% x1 k1 d' [9 d0 ]Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
6 i2 x" h  x% K: T" a" \4 V5 P------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
! R6 B4 W0 K* B+ ~Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
. Y8 \' |& Z2 g0 e2 r6 J{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

第三部分：
8 U+ K) H3 f: N8 Y----------------
锚
0 L. \# u6 e) D. n锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

3 K, k: D3 Z+ i# B2 Bs/pattern_to_match/pattern_to_substitute/


Table C: Regular expression anchors
-------------
操作
9 {# S' k4 r# k解释
) U' [1 A" g; C/ G4 ?例子
结果
. ?: [, K0 I! r---------------
^
Match at the beginning of a line
s/^/blah /
, @" w9 @: x1 V0 j5 \. E2 EInserts “blah “ at the beginning of the line
( p, W+ L/ P" U* H# N! x---------------
$
Match at the end of a line
  D7 m  G5 A& x* O2 ]( h+ ~s/$/ blah/
5 s1 |( ^' Z: rInserts “ blah” at the end of the line
  ^; `3 {' o; Q; P/ U---------------
' \1 z8 J# T; R\<
+ t6 ~7 c0 h- t3 c. QMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word

2 M5 ~7 H1 f  r. Yegrep “\Matches “blahfield”, etc.
+ M5 x9 V3 x  Y) a2 C. E------------------
- p( A1 J) M  v8 l4 y  }. E\>
Match at the end of a word
5 M! H7 N+ r# ~& b- Cs/\>/blah/
& N5 D8 }5 d' q% u0 r4 }: a0 K6 H  CInserts “blah” at the end of the word
( {" Y$ Z4 m3 _9 z
$ q/ T! f" u6 negrep “\>blah” sample.txt
7 p+ Y* \1 b; ]( I. B2 r6 \Matches “soupblah”, etc.
' s+ m3 f5 s9 p" s7 |' x1 K% U* V+ w---------------
6 f3 H, o* c+ C5 A5 ^& p: n7 x\b
. L2 F  \8 S* F& m* F& S: B8 KMatch at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
\B
/ B" {- d2 O. Q1 \! n) d7 Y1 LMatch in the middle of a word
7 j8 w' C! ]) H2 @4 v/ q) i$ o& p! S% begrep “\Bblah” sample.txt
Matches “sublahper”, etc.

8 V$ z. o" n0 h  c2 a+ u间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
% N+ D( q; M+ S- e  _
egrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
- e) @, t# R% J4 m" [
; C+ G: t; l$ P9 g5 tegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
( L4 E! y3 ~( ]9 \$ [2 j
1 l+ @9 i- C5 `; E. a6 X. R( @! d' D第四部分：
----------------
% K! R5 L) c. N8 G! i一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
. (period)
[ (left bracket}
+ d' j4 a* I: c' H8 S$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
| (pipe)
) f. F2 d  V8 s9 Y6 a- |* (asterisk)
: b0 m% ^/ u6 z, Y+ (plus symbol)
? (question mark)
+ ^- w& q+ C$ v' S9 a9 m  B. p{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
$ m( K3 P6 g2 Z. B! u) c# ^
' w/ Q* ^% s; X9 N5 Beregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
  y/ b  M. u% q8 D6 ^$ m: C( b
) H, b1 K5 ^! w. k1 q你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
0 B4 `. [6 G- w$ u" @
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

8 V4 N0 Y, _1 w7 i  `另外一篇文章
3 ]8 [1 I0 ]9 j% w* h" T----------------------------------------
正则表达式和Java编程语言
; f% @$ ^- R, K& S-----------------------------------------
, u3 A: Q" i2 @: a! w* |类和方法

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

! e& d! N: J1 F% o  iPattern类

" Q/ r3 K0 t& S, e& m% @/ HPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
" y5 J& Q6 H. l4 n' Q# `$ `
: O: q& I- g* w( ]( |用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
4 m3 q; V! C  L  ~3 ?
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

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

1 ?% R) [& O- f7 M  U, J/*
' C% Q; x4 g! \( i* 用split对以逗号和/或空格分隔的输入字符串进行切分。
) b. A' E" M- x0 f: b- ~*/
( C2 l2 u' _3 K$ W8 l/ Aimport java.util.regex.*;

; N' n- p$ y1 p8 s  u- R# F' Wpublic class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
. d2 ?0 B3 T+ N3 i/ @: u3 {( uPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
9 ]1 I4 c) ~' w( hString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
9 H( a: {, F* J! L+ i9 ^}
}
$ T% u1 {' r! V/ [+ W+ n
/ E0 T5 ^- R# o; n4 V0 uMatcher类
4 c: l* d# c% Y. L' T! Y( \
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
, W& ?7 Z) i( L: ^) _; H" U) Z/ k; B
- @- ]1 G7 G; `' i0 _: x通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
  s3 A& `2 ^& R; {$ I& |
matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
! t8 w; w1 c7 i4 X7 O- T
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
1 }& |1 i  b4 T- A0 e
! {* ]# w( ~' O& N/ J; @这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
- s% o; y# a- j1 ], L1 p" b
2 |2 R; Y5 L( Z# ]1 _  P+ r+ V例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
4 M: d) z, F) B* `* R7 s( d
! h- E8 F. ~9 Z$ N/ o9 GCharSequence接口

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

Regex情景范例
: }6 Z4 [. l2 x
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
( t6 o( y! q1 O- _% W+ s8 u5 O
" B- K- M5 Z$ V! p* W9 ]- N简单的单词替换

9 [: t; c) b) j" [/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;

0 l+ h8 y5 j- X; R+ ppublic class Replacement {
public static void main(String[] args)
3 Y/ R8 p- Y( K4 k: W  A       throws Exception {
0 P& c2 v$ R- X! U// Create a pattern to match cat
9 I. A* B7 C& q" h& F$ ^. KPattern p = Pattern.compile("cat");
0 ?& d0 e$ H! w+ m0 P5 y+ b/ h// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
- C* u7 W1 T* _     " two cats in the yard");
1 D% ]0 O+ K. y8 x/ k6 ]. ZStringBuffer sb = new StringBuffer();
  r& Y# S- A/ U- }) ?* lboolean result = m.find();
) m! q& K1 ]  ^4 b! x// Loop through and create a new String
- r" S/ @; E4 v// with the replacements
) q  }8 W2 y8 k3 Y* u; z8 B% Uwhile(result) {
' i$ `9 v+ Z! ym.appendReplacement(sb, "dog");
result = m.find();
/ @6 v8 z8 r: K}
& ]$ i$ y; E+ B// Add the last segment of input to
// the new String
* ?4 J3 S/ G5 D7 K- Im.appendTail(sb);
3 S( T; N: M- i3 K5 \6 W8 z* WSystem.out.println(sb.toString());
}
! h& E; G2 k+ R% i( D6 |}

电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
* Checks for invalid characters
, l( l- A/ q' B+ {$ e* P  l* in email addresses
) X$ D1 E, _+ O. A# C2 z*/
public class EmailValidation {
9 Y4 \5 t4 h/ N* w7 Rpublic static void main(String[] args)
           throws Exception {
) J( F' s- t7 A           
String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
: l" m; a4 y% Q' v. J) F+ k  {Matcher m = p.matcher(input);
if (m.find())
) I% p+ D- [  kSystem.err.println("Email addresses don't start" +
         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
/ W3 W1 c' Q+ E7 ]: R2 [; XSystem.out.println("Email addresses don't start" +
+ c( V, @/ `  b# O" {   " with \"www.\", only web pages do.");
/ I7 l+ T1 X9 a6 P}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
3 I- G2 x) l* Q8 _0 T& Gboolean result = m.find();
boolean deletedIllegalChars = false;
6 D( I2 l2 U* U, n
while(result) {
) f4 Y" W- ]  C$ rdeletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}

// Add the last segment of input to the new String
m.appendTail(sb);
) b! P' U' m) k) I1 s7 C
% x# g. S4 m2 D8 |/ s" S6 |input = sb.toString();
+ a7 Y2 ^9 s) N
if (deletedIllegalChars) {
7 ~' K/ i8 I( P1 C+ E; gSystem.out.println("It contained incorrect characters" +
: G3 L/ K% X- k4 T! a, v1 I       " , such as spaces or commas.");
}
}
8 L, H. q0 q* h3 x: r7 k( n6 g- W$ E}
( u" ]" e8 C* g6 [+ q
从文件中删除控制字符

/* This class removes control characters from a named
* file.
7 Y8 J8 u# h" g" `! \# l1 J+ `*/
import java.util.regex.*;
import java.io.*;
, }" N. a, N; s' J) ?
public class Control {
+ q" q/ o2 z$ y, y" a6 [( D: Jpublic static void main(String[] args)
8 U( r. I1 J+ Z0 ?9 i( K1 A, G           throws Exception {
           
//Create a file object with the file name
//in the argument:
6 x0 w3 t# O4 n& ?, C7 \& xFile fin = new File("fileName1");
: r' e  @7 k6 A" [, Q5 R5 h9 FFile fout = new File("fileName2");
( _2 ~- Q' c( N6 A6 I; V//Open and input and output stream
1 j+ w2 b3 m9 MFileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
% s& b+ W+ v; z# D       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
' h, p) W7 q1 r( J; v% L# r     new InputStreamReader(fis));
9 T7 u, `. u0 b* }5 ZBufferedWriter out = new BufferedWriter(
0 R- r/ o5 i: w$ @/ b     new OutputStreamWriter(fos));
) S1 J3 a. w$ t* h1 R
5 ?9 G& s: |' g" ~// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
  M$ r" j+ d( S; G8 F4 b% Uwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
& y; R- s  p5 d  W, L* C//string.
2 }1 K/ I) a2 ]9 T  A, YString result = m.replaceAll("");
8 |( ^$ [9 k; ]7 dout.write(result);
out.newLine();
}
in.close();
. E$ C4 p9 p# j. eout.close();
: E$ X0 c) _8 c: P}
}

6 i% ?/ g3 Y6 m3 t文件查找

/*
* Prints out the comments found in a .java file.
4 f6 @- }/ ^2 }2 ^+ V% v*/
9 D5 j8 Q8 L! ?  K& A# c3 Jimport java.util.regex.*;
import java.io.*;
5 ?( H# _& @% \import java.nio.*;
import java.nio.charset.*;
1 F$ y8 C4 d0 H# ~import java.nio.channels.*;
" Z" w* F$ D! N6 \
public class CharBufferExample {
+ P2 a8 Z) r, t- _1 ~public static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
  L2 e' [7 C  h9 a, i( BPattern.compile("//.*$", Pattern.MULTILINE);

$ s( b3 [$ t# h1 [0 i  M, u// Get a Channel for the source file
File f = new File("Replacement.java");
7 C& O" @" O" @1 S4 BFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
' C- J3 o+ L6 U- ~9 v& S; |3 F8 F
// Get a CharBuffer from the source file
$ M5 \" {- ^. m# B5 ZByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
4 c; E# Q1 E8 z  E# R; mCharBuffer cb = cd.decode(bb);
- a* c/ N" p. K. ~& h% v
) @) M, j* D2 Y2 V// Run some matches
- o; s7 ~2 V+ V6 [5 y' E8 A8 }Matcher m = p.matcher(cb);
while (m.find())
! h& y' ~6 r! W8 ~! P, A. N" ~/ N& a, ?System.out.println("Found comment: "+m.group());
}
}
5 F+ S8 P* O9 }, x, r) \
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
) h! K2 J; E% @/ i2 k1 \
8 q* H# J' x/ d2 K) Q7 B+ GJDK1.4之正規表示式
# l1 U" ]  Y. t5 M* |written by william chen(06/19/2002)
  G5 J; [/ l  Z# |
$ {5 @5 J# T0 [% H( d; E: V--------------------------------------------------------------------------------

% r, d, _$ J/ Z+ {什麼是正規表示式呢(Reqular Expressions)
6 E8 J3 ]- {% r/ n/ I
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
- v1 `  f$ M6 i
5 z; G0 c6 N$ r3 @$ }- }因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式
0 z# B6 [& {' ~! R. O5 h7 U4 x
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
0 `' v1 B& P: F6 d
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

9 }5 ^. z( k8 }9 R0 T2 Z1 Y剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
* Q6 q8 e  s3 h1 G
"." 代表任何字元
2 O4 M* s: G6 n' l. v* p
+ I" d6 W4 ]# U9 G! G8 O) E正規式 原字串 符合之字串
. ab a
* v- ?8 K0 O6 Q$ l- z$ c.. abc ab

"+" 代表一個或以個以上的字元
* Z: B8 v: s0 o3 m* K"*" 代表零個或是零個以上的字元
$ g9 B! v. L( }0 Z4 E! |$ h
正規式 原字串 符合之字串
+ ab ab
7 Z  z& ]) [0 i2 t* abc abc
. ?& N8 N& h. @; ]5 \3 }2 |
( d7 T: x- y7 w: H"( )"群組

- L: l8 d) J( V. |* T9 b* m正規式 原字串 符合之字串
(ab)* aabab abab
6 J) J! Y, A& f5 a
字元類
! Y  q5 o2 U8 L. t
正規式 原字串 符合之字串
" z6 B; p& [6 v[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab


( k* y: c! H- A/ b8 J, E簡式

4 Q- b# f/ H5 R6 }) w\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
$ r/ |. W% q( y\s 等於 [ \t\n\x0B\f\r] 空白字元
. a; T( e' a. [2 l* X4 ], w* X! U\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

^ 表示每行的開頭
$ 表示每行的結尾
' c6 u0 D$ f' [4 R- ^3 H
--------------------------------------------------------------------------------

正規表示式 java.util.regex 相關的類別

" w% r( h% X+ E- ZPattern—正規表示式的類別
Matcher—經過正規化的結果
! J; [. N% f% ^7 y' |PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
. y" C4 k: o6 r4 ]; r* b5 T9 k
範例1: 將字串中所有符合"<"的字元取代成"lt;"
% ?! W8 w# Z* j2 w' z. J, R0 g4 P
import java.io.*;
! n+ A$ h' n4 F7 {, kimport java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
+ [1 C/ J; V/ }*/
0 {7 y) o+ P+ l3 `! @: R! spublic static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
% t# T* W8 V( yPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
. ]% {/ i- Q+ k8 K# c( ?try{
8 r- a- q  G" B- owhile (true) {
1 M5 S% [3 R+ m% \String line = br.readLine();
// Null line means input is exhausted
' _1 }- u) J" Qif (line==null)
break;
Matcher a = pattern.matcher(line);
% q2 I8 g# |3 ^1 \7 ~( ^while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
% n7 s# e* N) {( X}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
+ T( z5 v. q8 @5 i, B9 `5 d* `1 }}catch(Exception ex){ex.printStackTrace();};
}

範例2:

* h5 w* X: y0 F7 c2 B. ^5 b; \import java.io.*;
import java.util.regex.*;
2 }' {4 ^7 g! z% D1 j/**
, u7 c- q. i3 R* @1 ]* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
0 [+ j- ]  h: ^' D*/
9 i. B1 |# j. V2 bpublic static void search01(){
7 H  M+ ~0 A. m6 Y* F) @0 y2 ~// BufferedReader lets us read line-by-line
# T  e4 |( s  U) f% e+ L/ mReader r = new InputStreamReader( System.in );
+ X0 b. D/ m. D" LBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
( f& y( d# W7 G9 [0 ]try{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
5 ]/ p/ ?5 k+ g4 S: Y9 e9 b// Null line means input is exhausted
1 i% Y" z- N) S" r8 jif (line==null)
break;
// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
" r: _. q4 Z* E' Flongest = i;
longestLength = words.length();
( k7 \; b+ Y+ T7 G" m}
' c% @9 z2 v2 R' u}
System.out.println( "長度最長為:" + words[longest] );
}
6 K4 I( ?. n6 t' V7 U' ^}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------

5 |5 v1 W3 b# M" {- x其他的正規語法

1 T6 Y9 W6 g* k( m" D+ `3 X2 f& ]/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水