查看: 735|回复: 1

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

Longe

管理员

论坛测试[砖]家

Rank: 12

金币: 7316
贡献: 615
威望: 9151
最后登录: 2026-8-24
帖子: 1875
积分: 25896
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);
% J7 n" T/ y" M* G}
2 l" ~3 A$ Y4 ]) a0 k3 @3 N0 w}
. r$ a6 A' ?$ U( c6 X) R+ X1 d. G% m. a4 [  `% `
Matcher类
2 U' t9 w6 h' C) N+ k" R0 e8 A# K/ X& h( M7 m
Matcher类的实例用于根据给定的字符串序列模式，对字符序列进行匹配。使用CharSequence接口把输入提供给匹配器，以便支持来自多种多样输入源的字符的匹配。2 m& G  Q3 k6 x. W5 r1 k5 E

8 i6 h! x8 a3 U( t2 p/ C# o通过调用某个模式的matcher方法，从这个模式生成匹配器。匹配器创建之后，就可以用它来执行三类不同的匹配操作：
# s1 k) K7 {# j
9 I/ i% h) ^2 wmatches方法试图根据此模式，对整个输入序列进行匹配。 ) p, q7 n2 Z4 B# @- {+ O$ ~3 f
lookingAt方法试图根据此模式，从开始处对输入序列进行匹配。 ) `0 p1 K$ t# x& D
find方法将扫描输入序列，寻找下一个与模式匹配的地方。 3 Q7 u6 V- J& v6 G- y; \
$ {' X2 n$ v  e/ U* J
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询匹配器的状态，可以获得更多的信息
- g& ~4 K' D3 q: M$ l7 m* _5 o0 ^8 e8 A: _& ~
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需要的话，可以从匹配结果推算得出。0 i5 y3 Z. @; M$ a; [4 h9 n3 d

. E0 U  C3 N8 e2 H# j' U. {& wappendReplacement方法先添加字符串中从当前位置到下一个匹配位置之间的所有字符，然后添加替换值。appendTail添加的是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
. w8 q) i9 K7 b# f
9 v% F" m6 j" {; d' T, e例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例简单的单词替换。
3 ^; G* @( ~/ }1 w  l  X' K
( Y# ]$ R/ N, f5 x) ^* g( e" \CharSequence接口, t' s. p. k& k) w% o# W

8 O" \( i/ ~5 ]* n0 F8 v, W8 uCharSequence接口为许多不同类型的字符序列提供了统一的只读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可以通过实现CharSequence接口，编写你自己的输入源。4 G. s1 `6 A# V

7 ^+ D, j5 `% S* o. m% p" y" W8 e% r) TRegex情景范例
5 N: P0 H  i& `$ }0 k/ m* S9 }5 u3 J* H
以下代码范例演示了java.util.regex软件包在各种常见情形下的用法：+ h: E( v, X) r+ R
5 g+ J0 q$ M& e; X5 D# f
简单的单词替换+ l4 A  S( X/ a+ @
4 k0 }4 G5 }6 [
/*# G9 Y7 @( b/ L, u  Y- Y
* This code writes "One dog, two dogs in the yard."
9 t$ b8 `1 N0 v8 X7 E9 O1 v* to the standard-output stream:$ |! c; W2 U5 [4 l* `
*/" o( K  r2 B% H  K
import java.util.regex.*;
0 F/ N' i' X. M( T1 n9 Z+ |4 I# P9 i+ u) Q9 R4 N+ K) H. X
public class Replacement {
8 m1 S; g$ w- @% J* G" ipublic static void main(String[] args)
) \6 q, u  \8 v- _7 I3 l    throws Exception {9 p; O: K: n2 H/ Q8 l# d* C, X
// Create a pattern to match cat
" i' y% T: {8 T9 U& MPattern p = Pattern.compile("cat");
8 ~2 c* e, h  T1 R// Create a matcher with an input string
, h6 i  Z6 v$ I6 L2 b1 C2 VMatcher m = p.matcher("one cat," +
/ M% O% F* Z7 E6 Q. H    " two cats in the yard");2 O  `+ k' a9 Z0 b# Z: y# K' R
StringBuffer sb = new StringBuffer();
( j( N% Z4 I' T8 N' k8 eboolean result = m.find();' q0 v! F' n+ b5 B, Z/ ^* X/ l
// Loop through and create a new String ' z9 o$ c* v( L8 z. f/ r: D
// with the replacements! X4 d# @; |+ g: W1 l% J
while(result) {
" y& m3 U/ r$ n. i( c+ um.appendReplacement(sb, "dog");
! S* S5 Z. Q% Z( qresult = m.find();
& R: F% \( m: T/ ?4 |}9 \  [1 m: L( f$ p+ O1 E
// Add the last segment of input to : b- L' V7 p6 f( ?+ u& o  C
// the new String# R3 |, b5 u; j( Q
m.appendTail(sb);( B5 m' _  e0 |, F  G9 b
System.out.println(sb.toString());
6 E1 ~- Z; ^- |) s  Y}
, x8 j+ [( j8 g, u% o' b}; x* Z- |' [1 d% E$ q- L' M
0 D! N1 I5 V6 g: H4 o% K* ?
电子邮件确认" ?' @8 f0 ^4 d- j6 {4 g6 f

/ q0 i) q  f- b5 u/ I以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在需要时加上它。* L# Z; A4 G/ j, @$ {

7 Y$ @0 w! k7 j# Y' i! C4 [/ N/*
& P& E$ b2 ~! M* Checks for invalid characters, V1 @: ?( b% m- P/ b5 P- q6 r) g
* in email addresses
9 ]) j# C0 g3 ^& r6 q2 \5 S! E*/: E5 y4 K+ u. n6 o' Z
public class EmailValidation {, p6 y$ {! n" n* \; d: K; P
public static void main(String[] args) $ y% h3 w/ S0 Y* w  g3 c! \
         throws Exception {  ?- F; B: X1 v; J/ `

- _) I; C0 O% ]1 P- ~& g) c: uString input = "@sun.com";$ P2 L- ]5 `7 }7 b8 r
//Checks for email addresses starting with8 s0 m" Q4 S- r* N
//inappropriate symbols like dots or @ signs.) \2 X/ s" y+ B: i& \- m$ d& ~
Pattern p = Pattern.compile("^\\.|^\\@");
" G6 f- G" b5 b& a& u/ ~/ TMatcher m = p.matcher(input);
1 V) H% |  J2 c% ~, j; cif (m.find())
% F$ e& `: P  o* W; ?System.err.println("Email addresses don't start" +
# N( O+ U1 m6 B8 [* x* ~* R4 W       " with dots or @ signs.");- E- Q9 c7 g# Z8 Z- E$ I
//Checks for email addresses that start with4 u+ H/ q3 s. `
//www. and prints a message if it does.: k" R) u- w! s/ p
p = Pattern.compile("^www\\.");
0 M$ O! y* n! E# e4 A. ^5 Jm = p.matcher(input);6 c* ^, y) R! Z: J7 D
if (m.find()) {4 b1 j# O2 L5 {2 g  S
System.out.println("Email addresses don't start" +
4 \0 ^& R0 x$ [% u5 C! g7 a. w " with \"www.\", only web pages do.");; w$ j- M) Z" K
}. _# z& h# r$ W: l  N2 w
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
$ k' J3 ^7 V% G+ }$ x- Km = p.matcher(input);' S3 z  Q$ y. n- f( V' X( J9 t
StringBuffer sb = new StringBuffer();* u7 M5 ?- ?# d4 J2 {
boolean result = m.find();
' {7 H/ _/ N; a4 R6 ^1 q$ oboolean deletedIllegalChars = false;8 L' \8 t' W) L/ n) T' [! M% a

) E. Q2 k9 h1 n( _4 p1 Q* x9 Lwhile(result) {: {  G* b3 p7 Y4 q5 M2 `8 j. u7 `
deletedIllegalChars = true;7 ]; b( l) C$ U, {5 ]* z2 u1 Z
m.appendReplacement(sb, "");
! D* F' Q9 v" d, c1 d. b" oresult = m.find();
1 U  h4 v4 `) H6 Z* r. g- H}$ s# \8 a, Z  e) _

+ b2 {7 v1 B1 W" |7 A// Add the last segment of input to the new String  G3 q$ E! L- M& D! \2 y3 G1 z7 x
m.appendTail(sb);
) `/ c4 z; x! x! t' |6 g* @/ Z$ x" g
input = sb.toString();
$ u6 ^6 ]# l! I: y/ [! j  A6 O* K$ i# k6 y; A% ?, }( |: u- r
if (deletedIllegalChars) {' S; ~& h5 x" u' H
System.out.println("It contained incorrect characters" +3 [2 s! }" A) P  [* d
   " , such as spaces or commas.");& P2 v+ C% Y1 a
}
/ d, w4 t% X5 Q9 o  A9 j7 B9 W. l}8 V% a' V* Z) n+ X$ U& i  G- D2 ?
}& C0 y( ?% _8 {5 ^+ X9 F

6 t- r. b) H9 o2 W8 @从文件中删除控制字符- Z( W. Z4 ~0 F5 j* v5 X0 \
+ D/ m# R! k* f, Q) f! e9 ?2 l
/* This class removes control characters from a named; X2 ~- p. m! x/ W+ ~4 _! k% x7 ^
* file.
6 N: d3 v4 S- d6 j*/6 c7 f  F3 Q0 y0 E& n
import java.util.regex.*;2 O& X& }9 Q) w3 \3 T# Y
import java.io.*;! d9 R) Q+ r( u

3 K' ^3 e/ m1 Y; A) Ipublic class Control {
% D; {9 t- W4 P6 [8 ^9 Hpublic static void main(String[] args)
* ~# Q) k) z6 L          throws Exception {
6 D8 C5 v2 p; }  E- E% \# e) y3 z- n          , |' @7 q4 g* v9 `
//Create a file object with the file name
  h! v! x$ ~2 j//in the argument:
4 b4 w4 ]0 X9 f- A& lFile fin = new File("fileName1");
8 G/ @$ h- {/ e1 wFile fout = new File("fileName2");
9 m* T& @+ M8 r7 [; ~2 ]' f//Open and input and output stream9 M9 B! R4 q" l) }  E' v' v
FileInputStream fis =
5 L4 x  @$ @6 B. |    new FileInputStream(fin);
5 P# o0 N* b# M/ L. L4 p5 KFileOutputStream fos =
1 E' w. f- M; m/ e    new FileOutputStream(fout);
' ^- R; ^' m/ r8 R" n: Q
: J! O# z, L: y  WBufferedReader in = new BufferedReader(
$ C' |3 `" W$ c. u4 v& X    new InputStreamReader(fis));2 B7 R9 o0 o3 p4 s7 p
BufferedWriter out = new BufferedWriter(% j: r4 u, W' ~2 d  ]
   new OutputStreamWriter(fos));0 U3 e7 o5 [+ p  `2 }  w, ^. b
7 L& K8 O4 O4 d7 _. B& u) q$ H9 K3 E
// The pattern matches control characters$ P9 }6 l- S9 L# k$ Z" c
Pattern p = Pattern.compile("{cntrl}");( j  F. N' Z+ v0 P, q2 `  l9 s
Matcher m = p.matcher("");
& x, f1 T  n% x& I7 QString aLine = null;
- E: g8 v2 b4 |while((aLine = in.readLine()) != null) {
& U" x8 y  |7 _5 E8 [. X, Tm.reset(aLine);
9 y3 ^3 S+ Q; T- {1 \% p//Replaces control characters with an empty% Z* d& K9 K& X. y  {5 J
//string.. P' G9 M; h+ U1 p9 [3 u2 d
String result = m.replaceAll("");
& Z( C* S  i" A$ Q: _out.write(result);
7 e' i) t, f: t# u6 l0 [' vout.newLine();/ D0 D: M! V" W; \5 [0 }
}
( E4 h/ p* l( i4 y# H7 p9 k. K8 @in.close();3 _% _" O5 B" o2 O
out.close();
& a6 o/ p1 ^: X8 m) d}! }/ r/ ]2 k+ e/ ^6 S9 {9 F  _! G
}8 N9 _2 q9 p% d
/ o$ V, b5 r: J; n6 k, ~
文件查找
! K. |: b5 [" D* p5 J9 _7 M9 _3 l* v$ @9 n
/*
" C; t" [* X( f5 V8 K9 |# ]+ m* Prints out the comments found in a .java file.* p) }. k/ C% u4 q! R$ [& b
*/
5 y& p4 e& @4 r9 {& Wimport java.util.regex.*;
/ P+ j% w9 C6 c$ _" ]8 Y2 ?import java.io.*;
! ?7 q- q3 q  p' S* ^import java.nio.*;' K' }( K: l# w
import java.nio.charset.*;
8 R3 A$ ~, q" ~6 [; j, Jimport java.nio.channels.*;
3 S* I  z0 s) I; ]4 ]2 A+ T0 a2 O9 b% N0 h9 i2 e. f
public class CharBufferExample {
6 D- [! A4 Z' o& b# F2 ^public static void main(String[] args) throws Exception {! {5 ?, q- s. Z7 x+ z7 z  J( ]; N
// Create a pattern to match comments$ J! I6 ^( I# L
Pattern p = . W5 ]8 E+ G! t$ G7 b
Pattern.compile("//.*$", Pattern.MULTILINE);
1 j: I* l( A- Z5 \8 v; C: ?4 Q- Q+ ?$ d+ C# b' V6 n
// Get a Channel for the source file; j: J. B3 _  _5 z
File f = new File("Replacement.java");
& `% R0 `; ]  c+ D/ ?4 @) [0 @6 ?FileInputStream fis = new FileInputStream(f);
9 I1 y2 e8 J- n8 p) @FileChannel fc = fis.getChannel();' w9 F/ i/ W) l, Y& |" i  N, K
9 t7 o' o) A/ i6 T
// Get a CharBuffer from the source file
6 g; A- D5 E& X  U2 w" \9 G) H% WByteBuffer bb =
2 ^) c' B8 t3 L. W6 Nfc.map(FileChannel.MAP_RO, 0, (int)fc.size());' s: @' j  r8 o0 r) g- \$ y7 H& @
Charset cs = Charset.forName("8859_1");0 D  _9 v7 P5 q0 N# O
CharsetDecoder cd = cs.newDecoder();
0 s+ O/ P$ ~0 c; m7 Q( tCharBuffer cb = cd.decode(bb);
- V6 S" M8 Q* `1 [: x. ~# R/ M$ e+ P0 j: f
// Run some matches
7 r* |* u0 L( Q& |) AMatcher m = p.matcher(cb);
% m. }) U8 N% `" ]: W- T9 Vwhile (m.find())  H3 B1 z! D- R! t8 E0 ~
System.out.println("Found comment: "+m.group());
1 k% r! n/ \. W, N! x5 y9 m" b" a}
, l. V5 S; o9 R% M2 b+ ~}
  K9 P3 R; |+ M
4 R" b- R9 }6 a; g: u结论
) v7 }! A  l! O' [& J) ]3 Z) e: {" F现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之，在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。 ! V) c" w8 i* q5 T
& [7 J: Y8 D7 O. R& w' Z  m
JDK1.4之正規表示式
2 G2 x, Z$ K* I+ y% M) l) U6 Twritten by william chen(06/19/2002)! M' R# t) J9 p; T$ e8 }6 P
7 u) P; I4 q" C4 b; J6 b, l
--------------------------------------------------------------------------------8 C# a# a. X( I% S. F
. O6 G3 V" ^) f, K. Y
什麼是正規表示式呢(Reqular Expressions)0 Q8 p1 `$ j! n! j+ \- O
' W7 L0 o8 L+ m  {3 D; q: V
就是針對檔案、字串，透過一種很特別的表示式來作search與replace" p, p1 w6 V9 ?6 ]4 \7 d
: {, Q' k' A- j* i2 `  R' t" D
因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
8 @* h3 G+ e5 g2 Y% g
2 A0 p2 j7 m; [5 h& ]6 w) d0 q3 I所以發展出一種特殊的命令叫做正規表示式& P" F* g9 o( L. |9 G
  ]) f/ e. l5 B- w1 D# T. k% Q
我們可以很簡單的用 "s/0 Z& f6 t! ~' X7 o  `
因此jdk1.4提供了一組正規表示式的package供大家使用
( }4 d& \2 V2 Q- P# C$ ^0 O* o6 G5 g! I5 K+ _8 D: v0 \6 j
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package% o: L* w& B! w/ T+ E; r3 h/ J1 z& _

1 w% {2 j* ~9 M剛剛列出的一串符號" s/
/ b3 Y  N0 s; d* g8 c* _' B適用於j2sdk1.4的正規語法$ y4 l) m8 i0 }4 Y" G7 W% W8 j4 \

6 Q  }. V! L- A0 P"." 代表任何字元+ D1 J0 o  y6 N

2 |( U8 u/ X1 |/ ?正規式原字串符合之字串
: ~, T4 e) {7 _1 |1 }. ab a   i" X  p7 x  ]$ Y$ o
.. abc ab : ^- Z# D- N' }) v( b

& K! k: g4 L0 p"+" 代表一個或以個以上的字元; {6 S) [% }' U' H! k: l5 V* Z8 _
"*" 代表零個或是零個以上的字元* [/ ^) a4 x" h! f3 b; Q9 C& y

, c8 d% W3 C2 u4 L4 A# u0 M正規式原字串符合之字串 1 S" G+ _! W6 m" |
+ ab ab
) @2 ]. ?' q2 i: B* abc abc , C) W( {+ r7 r; i: f: t

- ^7 _( k5 ~, F1 ^$ d. R"( )"群組3 B! X4 a5 r$ M+ V. W8 U" Q

% {1 A# g6 N0 B- ?正規式原字串符合之字串
' F- _9 D" @; t3 y8 E& R7 t(ab)* aabab abab 8 e4 m" T3 ^8 t4 i% ?  G

0 e3 M# b: t, l2 h8 k7 r字元類, B* V8 a' I& d

+ r+ c) @4 I9 S& g% Q- v) I正規式原字串符合之字串 7 N. J- e2 ]: t- p+ U- y& O' F; t
[a-dA-D0-9]* abczA0 abcA0 0 i2 |$ o7 g" u# h
[^a-d]* abe0 e0 7 b, N7 y1 ~' ^7 B: n2 e( T: a
[a-d]* abcdefgh abab 1 g( i/ i3 c& G& m& X& k4 T

6 S& T6 r+ [, A' D8 T8 f
0 D( @" J! v7 T' z' {$ [' G簡式
. V+ i9 Y% s; X0 c- P+ O, I
5 `, X% j# _6 N; c4 r7 B9 o" x\d 等於 [0-9] 數字
8 Z! D! x. H% ~/ Q, I' I\D 等於 [^0-9] 非數字
! N, {" I# d: F  j5 {\s 等於 [ \t\n\x0B\f\r] 空白字元
% E) v8 I2 k. j8 o7 \' b3 Y\S 等於 [^ \t\n\x0B\f\r] 非空白字元
/ E' s' I  c9 F" O5 g\w 等於 [a-zA-Z_0-9] 數字或是英文字
/ w% P/ K  c' Q7 Q: E+ L  k. A6 W\W 等於 [^a-zA-Z_0-9] 非數字與英文字
- k8 a. @3 W- @5 ]! ^6 z' i. x8 D2 {
每一行的開頭或結尾
9 w/ T  l2 z( a6 R& g) i' g* S9 ~' _. I  J6 P8 V4 `
^ 表示每行的開頭* S) r5 y) [& a$ J! B7 i4 ^
$ 表示每行的結尾
6 p' o9 ]2 J7 M% N0 z5 `" D4 I7 E1 w" _
) Q7 N: e$ N5 J--------------------------------------------------------------------------------
8 [& L* `4 z/ Z' N  `$ Z8 ~( ~, g, E( x7 m; v( ~
正規表示式 java.util.regex 相關的類別
% h- {# `4 I- t# b1 T: p" G9 w* e& B4 ?& F
Pattern—正規表示式的類別
8 e; [* Q# @2 `Matcher—經過正規化的結果/ s) [5 W5 U  x, Z$ b% o
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression1 q' D" z2 F7 V: ]  A1 a

) h4 Y$ }' u0 u" p範例1: 將字串中所有符合"<"的字元取代成"lt;"
& v3 r8 b- a* B$ f( h* v- V$ l+ e1 `6 k3 O2 h
import java.io.*;" `7 W! ^' x" v; r9 v4 s
import java.util.regex.*;
3 \. x3 S( y; C; x9 d- ~8 v/**& Z; d/ c2 ^: p) x7 z
* 將字串中所有符合"<"的字元取代成"lt;"$ s+ s& l! A# t) K9 K
*/
- q: L' D& p! Q" |' `" p# ]7 ~public static void replace01(){# g' y9 f( w8 ~2 L/ l' B! c
// BufferedReader lets us read line-by-line" F! S- _. L# C5 U
Reader r = new InputStreamReader( System.in );
: X" {: i, H, A9 q) V' I8 }+ [BufferedReader br = new BufferedReader( r );
- u- Y* \; c3 E" FPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
+ ~5 D0 W7 J+ K, ktry{
- T( Y+ S! J, }/ D, P0 f' M5 p% L2 Jwhile (true) {
& x1 l$ L0 G; Q2 C4 s& sString line = br.readLine();# a- ?3 l- n  i: O
// Null line means input is exhausted8 ~: [* @- d) h5 B
if (line==null)! N. a" x  A1 N# N: m) v$ e
break;
* h6 V) Y  g5 P) @Matcher a = pattern.matcher(line);
9 X3 i1 d, y5 X( J$ x( _while(a.find()){
( a8 q" \* Y# `1 ySystem.out.println("搜尋到的字元是" + a.group());. g( a3 Z* `. c2 d1 }
}
1 {+ f( \. H$ a. M/ O- W' JSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
2 x, u/ P3 J' J% k}
0 r% p. d8 Z* H) d3 l; f}catch(Exception ex){ex.printStackTrace();};
7 Q0 X; M* i. F+ d}
% \; n& x% T, b
9 [, Z1 S& {( @$ l範例2:
9 n* _4 x  {+ a/ m  R
9 N' z4 `. I% q, j3 M% ximport java.io.*;# _# h1 Q  o& Z! C0 N* C7 A
import java.util.regex.*;3 q8 V! T2 v( P% _3 _+ u9 Y5 X. Y
/**
7 [0 @$ ~& y! D- q; w0 c+ I9 n* 類似StringTokenizer的功能  i, R' G5 q8 j
* 將字串以","分隔然後比對哪個token最長2 |" x4 e/ ]! e$ p# e3 H
*/
& R9 U/ g& Y. e  r* ], @3 `public static void search01(){! A  {. ?7 _7 n. B1 C
// BufferedReader lets us read line-by-line
6 M$ w# ~1 i/ X4 ^' u: H3 F7 f  aReader r = new InputStreamReader( System.in );
5 k5 O' _$ g& ^4 [1 o! oBufferedReader br = new BufferedReader( r );
# O6 g/ V" s- [& e. h  ~. ]Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元) U7 y4 M2 k4 e% f0 \- v3 S# W* n. `
try{
- y! z" X9 T3 y4 e6 A  Y- twhile (true) {
0 @3 W2 U, n, Z6 lString line = br.readLine();2 g- `8 s% [# r
String words[] = pattern.split(line);
' Y& v# S( G) _// Null line means input is exhausted! ]' [* c2 ?3 [4 O/ ^* ^
if (line==null)( ]; ?: e9 w. w# x
break;
9 O5 C/ R8 e$ Z( c& O9 K, j; G! Z// -1 means we haven't found a word yet+ m3 i/ N5 [; r3 s% z2 @
int longest=-1;2 L# z" r2 w. Y8 R  {: n
int longestLength=0;
' y: P  R" s% N- G* U# Ifor (int i=0; iSystem.out.println("分段:" + words );
" Q* T3 r3 z, [if (words.length() > longestLength) {
. l: n9 n2 X& m$ h" Rlongest = i;% ~1 s% u" i! p
longestLength = words.length();. C2 M6 M) Y2 o+ ?1 N; e
}
& Y6 N. {# V* \$ J9 G4 G- O& L}; }" $ t$ t) I
System.out.println( "長度最長為:" + words[longest] );( _0 E, R3 H2 D
}5 \( p. c  n# Y2 G. L# }7 L8 r, J/ b
}catch(Exception ex){ex.printStackTrace();};+ I6 z) ]4 Q1 |& Q
}- g/ N* m% C' P/ r+ f8 \- D8 k

. V( c- X" o3 Q7 ?" E--------------------------------------------------------------------------------
9 @/ `6 Y: c% I+ @+ G
2 o7 ~7 U$ p, k9 X其他的正規語法6 E# ^) i! v/ `+ t+ W; f4 Z! o8 k0 W

5 }0 Z! `% g. B. t$ _4 [/^\s* # 忽略每行開始的空白字元
/ $ b$ V; T9 k# Z(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)