查看: 474|回复: 1

关于正则表达式---ZT [复制链接]

Longe

管理员

论坛测试[砖]家

Rank: 12

威望: 9084
在线时间: 1242 小时
金币: 6984
贡献: 300
存款: 1660001
最后登录: 2026-5-10
注册时间: 2006-5-10
帖子: 1840
精华: 6
积分: 15415
阅读权限: 200
UID: 10

电梯直达

1楼

发表于 2009-11-9 13:04:38 |只看该作者 |倒序浏览

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

支持多种平台

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

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

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

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

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

第二部分：
----------------------
字符匹配

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

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

Table A: Character-matching regular expressions
格式说明：
---------------
操作：
解释：
例子：
结果：
----------------
.
Match any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
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

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [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.

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

Table B: Regular expression repetition operators
格式说明：
---------------
操作：
解释：
例子：
结果：
----------------
?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will 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.
-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{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.
------------------------
{n,}
Match declared element at least n times
egrep “.{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
egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/

Table C: Regular expression anchors
-------------
操作
解释
例子
结果
---------------
^
Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
\>
Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.

间隔

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

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

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

egrep “[nm]erd” sample.txt

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

第四部分：
----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

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

另外一篇文章
----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法

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

Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语法类似于Perl所用的语法。

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

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输入进行匹配。pattern 方法可返回编译这个模式所用的正则表达式。

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

/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
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
String[] result =
p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
( C4 M/ b+ c2 h4 w2 ]* F}9 p& |% l  w- U) f6 L/ d$ w- ?& G
}( l( ^# p+ Y9 e' z8 X) P" R

9 E, E- v: A+ x2 tMatcher类
, Q0 G) |+ b3 n5 r: s+ s
% M7 B, s. u" Y; }9 p* s! @Matcher类的实例用于根据给定的字符串序列模式，对字符序列进行匹配。使用CharSequence接口把输入提供给匹配器，以便支持来自多种多样输入源的字符的匹配。
% V; G$ {9 ?7 H$ K4 @9 K# @% `' }) Y$ j( L  u  ]
通过调用某个模式的matcher方法，从这个模式生成匹配器。匹配器创建之后，就可以用它来执行三类不同的匹配操作：* e  ^" C  M1 {- G. q$ U+ S

  x" i; G& m, |7 @% z" z: {matches方法试图根据此模式，对整个输入序列进行匹配。 # X5 s+ ?1 F4 l* r8 s) r5 f
lookingAt方法试图根据此模式，从开始处对输入序列进行匹配。
/ i6 p, h6 l) S, N1 v7 {* I$ V6 Ufind方法将扫描输入序列，寻找下一个与模式匹配的地方。 7 G$ m3 u1 c! D: T3 |6 D! K

) N, ~7 ^. t' b/ s; d# w' Y! x: Y这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询匹配器的状态，可以获得更多的信息
; i; |7 F# C+ M6 Q# ]
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需要的话，可以从匹配结果推算得出。
! j+ l8 ?9 X% D& x! V4 h
  B& s* N4 q" _appendReplacement方法先添加字符串中从当前位置到下一个匹配位置之间的所有字符，然后添加替换值。appendTail添加的是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
( }. w' h' M$ i- B9 D6 C, i* A# r8 m6 c
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例简单的单词替换。0 c3 r2 T) m) p8 q2 q
) Y) S  y0 t; P6 y) _% L
CharSequence接口
* h3 Y) Q: r- ~. ], }9 ?
  {6 ~4 g9 x+ E9 VCharSequence接口为许多不同类型的字符序列提供了统一的只读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可以通过实现CharSequence接口，编写你自己的输入源。
2 G9 D6 X$ H6 O& }0 r4 n$ v1 U' t: e! O- _2 X6 r1 p
Regex情景范例
$ a7 G6 N. }" W" y3 @0 J* j
1 [% s# w$ D; I' a以下代码范例演示了java.util.regex软件包在各种常见情形下的用法：
" ?/ l/ a* o+ i4 K
- }8 @% u5 c. |+ S1 `简单的单词替换
8 E& l" G0 {9 z+ Q, Y- B( k( }  U+ L% \! S0 z
/*# q  O* ?1 l+ @4 T, m2 L
* This code writes "One dog, two dogs in the yard."
2 [. N; }% r& [$ G0 f* to the standard-output stream:
9 x+ A2 B4 c5 T7 r% M( p*/9 y: [. M( x# I" \$ _8 |- |$ a; X  [
import java.util.regex.*;
6 ?- t$ m6 O7 k  d" f( R4 X: J# @5 e  P, D& S! t/ ^: b
public class Replacement {8 w; Z2 m" M! C: h0 s# h
public static void main(String[] args)
) E6 y& g/ A8 E/ |1 m    throws Exception {
% l; Q2 r1 j# t" S0 B) P// Create a pattern to match cat
3 s4 ]3 [7 b9 p1 ]; n3 ?+ yPattern p = Pattern.compile("cat");
( H  Q% K+ n' u' s/ L* u  u; R// Create a matcher with an input string6 L( U+ w( l! b- J4 L
Matcher m = p.matcher("one cat," +
- E7 d" E/ |0 a' m3 ]+ f9 h, b    " two cats in the yard");* O5 t; r% O* K0 `
StringBuffer sb = new StringBuffer();
' ^$ e" g8 {9 Cboolean result = m.find();9 C& T5 x; G9 U% Q
// Loop through and create a new String
2 s7 a4 t! B; V- r" j// with the replacements9 ~9 q7 B- V/ R* B$ }$ R) r
while(result) {
0 H) o% n# W6 gm.appendReplacement(sb, "dog");
/ j- l; ?" g* yresult = m.find();3 y  s, ?$ e$ k* L! l
}+ ]) i; i+ p0 N+ d/ c; x
// Add the last segment of input to / {: `- ?" v/ W; Z/ X4 I+ z$ b
// the new String
( \$ L" M) s: j$ |* Q- wm.appendTail(sb);2 c- W: N0 O( C. z% _4 v% V8 I
System.out.println(sb.toString());
  `+ W6 A) s) V}: [2 S9 t$ i, v" F4 I- s# V
}! p3 Y8 Y& T! S% r

  y, q; V- _7 a9 p  a3 Q9 }电子邮件确认
3 L( J% W  u% d* V! r
4 p! s7 H% r) q' ?; |' D' D以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在需要时加上它。
/ }' O! {3 s/ X1 I. k
  @- B, b: L6 F/*
+ n3 V' N) g( L* W8 y3 ]: s4 ^* Checks for invalid characters
/ y: d1 B4 Q5 H) d' Z* in email addresses
3 V  r- ^6 m% u1 K*/: M$ m5 M. \  `" A0 d: U! U
public class EmailValidation {
5 ~# D  j4 M" Rpublic static void main(String[] args)
# I1 S3 Q+ I8 S4 C2 W, m+ L3 M& F          throws Exception {
  x1 Z! r& f% |6 h! K, v" `          % B' L7 Y0 K! O2 F* g
String input = "@sun.com";
- |  s) t# g  p( a: H  c//Checks for email addresses starting with
" Q0 v4 J6 Q, ]7 @//inappropriate symbols like dots or @ signs.
7 _2 l3 F8 v9 H( m0 m9 RPattern p = Pattern.compile("^\\.|^\\@");' n9 G6 Y2 |2 }4 q) E9 \- o8 M* }. r
Matcher m = p.matcher(input);
7 g5 X$ W) f# Bif (m.find())( }0 Y5 s- p1 X
System.err.println("Email addresses don't start" +, {* M% o& v+ m, F7 d+ c
      " with dots or @ signs.");
2 M* q; v# I8 M8 _' [: ]//Checks for email addresses that start with: V/ Z) T, _9 N* T
//www. and prints a message if it does.
* q% i* p5 O, J. A+ f% Xp = Pattern.compile("^www\\.");) E2 \) D3 M3 g* z: x6 X% ~' }
m = p.matcher(input);
- T; a& q0 j% o2 B0 yif (m.find()) {- v# O" N8 q; _" ^8 P! W+ Z  p
System.out.println("Email addresses don't start" +8 y' [( k* Q8 C- ~) M
" with \"www.\", only web pages do.");
& O4 m* \# D8 s! b! X4 H* `9 ^2 N* P4 {}
; U1 F9 d% e2 `p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
! q8 d6 c/ x% r) wm = p.matcher(input);% o2 z6 q) ?: W  G  j$ _" H
StringBuffer sb = new StringBuffer();
boolean result = m.find();
3 L- o9 q- S9 Y5 R5 Bboolean deletedIllegalChars = false;
% R: i* j: b# Z, I9 ~& E9 ^$ P( R7 {# T4 p$ d: H1 q
while(result) {3 m4 x8 g7 E& \6 P8 W
deletedIllegalChars = true;6 y0 Y! |2 @) v" N+ \
m.appendReplacement(sb, "");! M8 Y, c  e0 m5 c/ M; P6 h; G3 c
result = m.find();+ ~# L+ t6 O" w9 ~9 ?
}
6 N. e+ x* V! S
$ i6 K1 |- q2 W! j  m& v/ i// Add the last segment of input to the new String
7 ]* K4 ]* R: k& U# n7 f6 @m.appendTail(sb);: }0 U: t$ W$ ]7 H. d

  s( I8 o) s$ s3 \* @: Qinput = sb.toString();# @9 @3 w2 Y2 c- T3 @8 A

/ H- a! j' ]1 y5 y+ l+ {1 n- O+ r. U( Gif (deletedIllegalChars) {
/ g$ w% |5 d4 H+ ^8 a2 w2 V7 y5 eSystem.out.println("It contained incorrect characters" +$ c; m4 S: r2 B2 z. c. j% o
   " , such as spaces or commas.");
" E8 ?  [' M" V' P7 p" S! g! m}# `4 Y2 ~' s: m0 M. l
}
/ Z4 Y& s$ c) R$ L}
$ [+ c, k/ B6 R( t0 e
7 y' O8 q; S+ N" H! |* s. }从文件中删除控制字符
8 m, {& c6 u9 l4 L& T7 U
: A) T# @; N3 K3 K8 i/* This class removes control characters from a named
% _7 I# m. [; f9 q% Q1 U# p* file.6 K# V( e  Z: a" v" d
*/  E. N2 ~) A& K  A3 p2 S2 ]
import java.util.regex.*;) V; N9 I& M( [& k7 N8 N% C+ \: c
import java.io.*;4 \/ S( R- `8 V
- d7 ~8 L+ ?8 [  V2 ?" N
public class Control {5 C. G' @1 b$ S$ V5 P7 f" K0 N
public static void main(String[] args)
+ t! W6 }; C, f1 J          throws Exception {
! A0 F% v& j+ _0 R# g          ' @1 f7 `7 o( `" j  E
//Create a file object with the file name% M7 C4 ^& j9 C( _
//in the argument:* G, m6 b' f' O. G
File fin = new File("fileName1");! {0 k2 M  Z9 U* n, m4 M
File fout = new File("fileName2");1 b+ Q1 T1 x$ U% P" I2 j4 d
//Open and input and output stream
2 s) m3 m: z2 KFileInputStream fis = 8 R: G) o& V4 n1 A+ _
   new FileInputStream(fin);& f# I( l) d" T# G/ o' P
FileOutputStream fos =
2 s* M4 T# M) R9 M4 @' {    new FileOutputStream(fout);
# w/ U$ S: M0 a3 b8 |) ?1 d$ W9 h6 X; Y+ v& z2 |
BufferedReader in = new BufferedReader(& ~6 [2 J- v1 Z8 J# S
   new InputStreamReader(fis));
, O# M, V7 j% |$ IBufferedWriter out = new BufferedWriter(- ^$ |9 }9 Y+ l) Q# S- ?
   new OutputStreamWriter(fos));
4 y" J2 d/ H# G5 o4 G2 ~5 @; Y7 t6 a$ ^3 C0 F5 V2 t6 p
// The pattern matches control characters
; z& B+ |# t+ D4 G+ }/ @5 `1 B4 VPattern p = Pattern.compile("{cntrl}");0 z  _# [2 l4 M. |6 I& C# b% |' z' d
Matcher m = p.matcher("");
$ f& p; G: S8 h  `. C( N. e+ VString aLine = null;
6 _1 p( M+ F' H9 c0 H( ]( m1 awhile((aLine = in.readLine()) != null) {
; A* R- l/ _# \/ v: mm.reset(aLine);
% f8 v# q( ]3 [4 R//Replaces control characters with an empty
. ^3 t/ V7 M( s$ W6 x6 R1 ~; l8 A//string.- u6 }( l* v- e" e. e2 G' W2 W% Z
String result = m.replaceAll("");$ i2 x  j' [6 ?  f0 d! l! j. Z9 T
out.write(result);
! [# d1 |8 g3 T& g, f/ eout.newLine();. h/ A/ b% @) G
}
* B& r% I: T. tin.close();( ]8 @/ J0 n/ O8 X! ^3 N3 X0 D
out.close();
% ^$ I: L9 N) C  O. B7 A% n; t}6 R0 {% T* r% ^+ Y9 r' B
}6 n5 |1 W5 D- r7 A5 T1 f+ M. G

& B1 ]+ w3 A/ t文件查找   T  k+ c; n* o8 e* {$ D8 ~1 ^- Z: w
0 o: }, ~) z- c) w  g- c
/*+ U" O, W* O# Q3 r  w
* Prints out the comments found in a .java file.% H, o  {& }: ?
*/
; j8 h- h% [7 n% L* D) d9 himport java.util.regex.*;
+ P/ H; c9 c# n9 s5 S* j* C* mimport java.io.*;1 g# b  @* K; k, z4 P5 v8 C
import java.nio.*;
! y1 l: c& f# e) J, a) Yimport java.nio.charset.*;
3 B& G+ h  j& Y3 R, p+ q; b: nimport java.nio.channels.*;# E  b' F& o7 X/ b

4 o0 c4 l. o$ U0 U( [public class CharBufferExample {, }, m2 T: Y, w3 c
public static void main(String[] args) throws Exception {  w5 w, F2 c7 g% J7 ~3 p+ ^
// Create a pattern to match comments8 V- m9 ~8 M: \6 n/ G7 |
Pattern p =
: W5 I" G" N/ E& _0 ?% }. ePattern.compile("//.*$", Pattern.MULTILINE);
! D* U2 u& Z8 S! X0 ~7 ^7 |, P
$ u) c, v: u6 n$ u3 s// Get a Channel for the source file
, ^& X6 l  O+ Q5 R. rFile f = new File("Replacement.java");
( R  I# r/ r8 ^8 ?+ E( gFileInputStream fis = new FileInputStream(f);9 K+ S5 \' G6 H' w; T- Z% a
FileChannel fc = fis.getChannel();( F: R: w9 y1 b" C. Z

: i9 b* o6 g7 ]! x// Get a CharBuffer from the source file$ ~5 `8 r: F+ J" }+ d
ByteBuffer bb = # P( W1 U% x- s. b" e
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
6 e& X: }1 d* C6 {5 ZCharset cs = Charset.forName("8859_1");6 s( K& |; G2 |' u  ^! C
CharsetDecoder cd = cs.newDecoder();( B. Z; P9 d& V$ J
CharBuffer cb = cd.decode(bb);: Z7 N! m$ p3 E* n
: O* }( s6 o  J& k! Q$ B# E" b
// Run some matches3 t  z" ]4 l& O4 ^0 z6 _
Matcher m = p.matcher(cb);
( a+ J* S1 F! {* A0 D, twhile (m.find())- d# c/ Y! Z2 @7 ]  s2 B6 l" z1 A
System.out.println("Found comment: "+m.group());
7 {9 T; k( J' a/ x}
1 ~0 X1 I$ p$ Q* h}
7 J5 S7 L! Y+ ^8 {3 k% i
% T) A% u5 g0 Z结论- P7 W1 @3 r; c6 }/ `
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之，在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。 3 q) O% ]+ x" s$ z% X0 ~$ D

  f$ t. k$ J' u9 @. |JDK1.4之正規表示式$ i8 q" f* m& X/ P3 s  F) i4 _
written by william chen(06/19/2002)
# l+ z5 J8 E& A
7 T3 g$ ?2 ?# I0 G( y9 U--------------------------------------------------------------------------------% e  f( m( ]2 c2 U- k

$ H* Z5 [" g% o& i什麼是正規表示式呢(Reqular Expressions)
2 @+ e' o7 n+ h$ P# y" r4 @% C; ?) b8 B& m8 B
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
! _" ]/ P  ]/ I& @5 x
( d0 P. A0 b1 @* Z, s- |( o" D6 [+ C因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代: l9 I; ~1 L! Y! z: K

* f' H4 Q4 ?4 ]" U所以發展出一種特殊的命令叫做正規表示式+ l8 I8 A4 N6 m, M/ r8 H
2 s) ]6 r: N! v
我們可以很簡單的用 "s/
! f3 o* v# u( g1 O) K5 _/ R1 Q因此jdk1.4提供了一組正規表示式的package供大家使用
4 U/ F/ q+ i4 O1 M& I; t: J
0 n( [! u3 P! v. M若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package) V/ G/ J8 k7 y! O! V2 ~

0 E$ J- h; S! f剛剛列出的一串符號" s/- ]% o. A4 g3 \* {
適用於j2sdk1.4的正規語法
2 f; p9 V! ?# a8 |5 t) |) b' o/ Y9 H6 E
"." 代表任何字元- {# V0 y- ?( P- U& v; k

3 s0 T" C6 G/ Y5 C8 X) t正規式原字串符合之字串 % D, u( k6 r& ]% @* l
. ab a & Z, h0 Q' m/ i/ j
.. abc ab
6 u+ W5 Y: r' L' q2 c( j: s- ^( }( T
"+" 代表一個或以個以上的字元5 k/ q" m$ {) D% Y
"*" 代表零個或是零個以上的字元7 a/ ^& c( \. B5 u% `! e( u
5 V4 D4 o7 ~( M1 G% ^6 T& n
正規式原字串符合之字串 ; N% E& t/ B6 w! ^& L
+ ab ab & ~8 L% `0 t' R# ]. k) O3 q
* abc abc
7 f- o. K% ^" M/ k. `" ~/ o
: E& Y7 d1 f/ v+ k: Y; ?"( )"群組0 j) X/ N+ c7 O% i
" @9 m5 P* y2 n( [2 Z  f* Y
正規式原字串符合之字串 9 q- k# C' X2 H! W& f  d% i
(ab)* aabab abab 9 F& u5 p& ^% a8 q

# o6 p$ v0 ^9 N, q0 ~* T1 A& H  u字元類; e  }" W; [. K( ]$ o

- @! p$ l9 e3 H5 e$ E; N正規式原字串符合之字串 & Q; O- X% B5 J
[a-dA-D0-9]* abczA0 abcA0
% k; f3 D- a2 e# l, P[^a-d]* abe0 e0 / Y) C& Z8 P  N3 F
[a-d]* abcdefgh abab
0 a; r/ N- _8 [' V( K
1 E& ^8 l; ~3 @* x$ P& j% R0 ~. A
+ a+ x' A* D& \6 }5 W# [2 ^簡式
/ a. I! S0 N3 t  g9 {0 ^% z
5 t! s3 ~3 w6 N0 W4 z, Z) s\d 等於 [0-9] 數字 - K9 v# m- H, i2 ?. B8 x7 s
\D 等於 [^0-9] 非數字 % Q* {8 y; P& O1 t
\s 等於 [ \t\n\x0B\f\r] 空白字元
) \* K+ `* a& h" r* s: p, s\S 等於 [^ \t\n\x0B\f\r] 非空白字元
7 Q# f2 v8 X  b* E6 J\w 等於 [a-zA-Z_0-9] 數字或是英文字 " ^* _! h; v8 B) K
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
9 T6 ^6 [. {8 {( q# ?" E) o! K) c1 A
每一行的開頭或結尾+ E& F  b1 }* _  O& U! ]. a

; p* }; q" U" o2 L5 w^ 表示每行的開頭0 V/ W2 R+ p. u1 T! f3 Y
$ 表示每行的結尾
9 Z) ]4 p- ]' P& h0 t$ e
$ F* A! I  Z. A. b- e& Y, s7 {. R--------------------------------------------------------------------------------
) E9 Z4 m2 t* Q0 H4 E! q2 k* I% S' W2 A9 F4 \9 W
正規表示式 java.util.regex 相關的類別 " h4 B) P  Y$ r  z6 s# L; S* B
% b& Q: x; T" J$ B
Pattern—正規表示式的類別
% _) {8 b8 S' ~( E) n4 @Matcher—經過正規化的結果6 C% W: k6 M( q2 t9 T0 q. u4 ^* M
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression9 e7 s! {) |$ S! b  t

6 t7 G# L' L# i4 R) O" W範例1: 將字串中所有符合"<"的字元取代成"lt;"
0 u9 ?& @% p, ~9 |1 ]7 y0 G
3 B3 [& V$ s( O) g; i3 [. Q' j0 m' Ximport java.io.*;' {( k" z! O4 D4 p! I2 Q
import java.util.regex.*;$ A% R" Y2 @/ u9 R
/**
7 `5 {* C$ q3 `  {  t8 u* 將字串中所有符合"<"的字元取代成"lt;"# R- h2 u$ J- E4 P1 R" A' L/ N
*/6 t8 H- t$ s  u" `: m
public static void replace01(){
) @3 @0 I; }9 ^+ `: t) ^// BufferedReader lets us read line-by-line
$ S0 C+ Q- ~. Q1 U& QReader r = new InputStreamReader( System.in );
- G- }+ I/ N& o9 u7 lBufferedReader br = new BufferedReader( r );
6 i% U6 C" O' SPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元( o9 s% A* U4 n8 [
try{
& I% {2 M  ~1 ~' i, K! ^while (true) {$ i! Q2 a) H: |" V, K; K. E
String line = br.readLine();
  ?7 d; W+ x9 x9 L// Null line means input is exhausted
  Z* ?! n, k& p2 w1 L7 Xif (line==null)
9 G+ j! ?# ?) T7 Y0 ?break;: |/ s, y2 O/ c9 S  H2 R- W
Matcher a = pattern.matcher(line);( l9 A/ D* O8 w6 N* U
while(a.find()){
. N& Y) ~  C. g$ t$ u/ U, s2 PSystem.out.println("搜尋到的字元是" + a.group());" r/ q. _! U+ @& o$ e
}
% w  b% Q+ W* n% C& }System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;5 A+ l. S8 v+ B% }" b: I
}% v4 D1 ~9 G0 t* Y  P& z
}catch(Exception ex){ex.printStackTrace();};% Z  A2 S: S. @+ A- K3 @
}& k8 k! \+ e: `  b2 M; R: X) q7 w

. A+ C, F, c! u, U2 d範例2:
" O) e! ?/ F& l0 h  d* E3 `" M2 v
import java.io.*;
% [' P. E: m6 B( q' ^& Qimport java.util.regex.*;
9 d2 L# R2 y8 h6 m1 I/**7 l) g) _: g/ z8 o) f3 @: }6 N
* 類似StringTokenizer的功能
2 v$ [4 \9 w* s" @: r: z3 U* 將字串以","分隔然後比對哪個token最長* V$ K! V3 q  X7 Y* }. f5 \, k% C
*/
" m/ H, N2 i" K7 q7 M5 q8 a- F$ Lpublic static void search01(){
; e2 k" u( f' v* D8 d8 O. ]& Q5 i// BufferedReader lets us read line-by-line
; p0 |, E. {4 f! Y! NReader r = new InputStreamReader( System.in );
' _3 q7 J8 D3 {4 t& ]5 r0 C1 t0 wBufferedReader br = new BufferedReader( r );3 t: q8 L+ U8 I
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元8 [$ [9 t: M, a* Q( L: {
try{4 A. K6 ?" d0 W# u2 w- k* n- c7 @
while (true) {
3 c: `  p2 u4 G! l$ kString line = br.readLine();
0 z- L+ f1 L! o9 k$ v2 f$ B: qString words[] = pattern.split(line);
! R, M& \+ P% a! {( g- n// Null line means input is exhausted
9 Y+ y; a7 r1 {. j  t% Pif (line==null)
8 I+ A& t3 Z) V" lbreak;
4 S  f; v$ X: i. l& V0 _9 n& _// -1 means we haven't found a word yet: E' C# d0 V( e. B2 {! S
int longest=-1;% B9 O/ j! M/ ^, Z
int longestLength=0;7 r% ?7 Y! }, k
for (int i=0; iSystem.out.println("分段:" + words );* z3 w  N' D; i! i
if (words.length() > longestLength) {
' s5 S% T, R: m* J) ^) D# Vlongest = i;; g9 _! b8 p6 @4 B3 |% q' i
longestLength = words.length();9 d$ J$ D/ T  w% h1 D* R, B& _" `
}9 x# |4 b) a  o+ T8 b! u( q: M( E  i
}
& T) w/ Z& Y0 @$ ^! Q; ?System.out.println( "長度最長為:" + words[longest] );
4 i8 J! k  q7 d, ~6 ^- ~- I}9 ?) L- M( U1 p" P! \# [7 i9 j
}catch(Exception ex){ex.printStackTrace();};! i+ }, {* S4 X" x- Q
}
5 v/ P% t5 b8 K$ A( s: @1 L5 z3 r( Y# b& D
--------------------------------------------------------------------------------" B5 J. F% \9 t2 h, ?" f5 j6 S
# t6 u9 L9 ]0 h! y! g* i4 s: Z
其他的正規語法. e9 X1 @, K5 s- l# m
% O4 f* ~3 l* f
/^\s* # 忽略每行開始的空白字元
- t/ n4 O8 q' K& D( A: y(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)