关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
- E* Q5 n6 d- n) U
7 ~+ t1 y; K6 x" L# A: ^支持多种平台

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

# W' q" q( A8 `/ M' T正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
/ ]. t* K- f$ n( p  o+ e6 S. H$ K
) w6 @2 _5 ~% d7 a+ c4 [许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
- g0 [! O" _3 l; i' [2 G
比你想象的还要普通
! k' s4 m1 ]* r随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

. J$ d  q) {% ]- C2 ?7 N) s/ c正则表达式101
) ~0 h4 k: {7 [: P4 Q2 j5 k: |很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
4 I% d' |: F8 P, Q. I* j2 X----------------------
8 h4 ~/ z: r4 Y$ g字符匹配
( d  f1 W8 }. C8 b/ z1 w
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
% a0 o/ C# H* E
每一个表达式都包含需要查找的指令，如表A所示。

8 `( N. F# \9 xTable A: Character-matching regular expressions
) r6 ?6 h6 q& `1 C9 i格式说明：
& I. t. Z+ m# h---------------
' Q# Q# N, G  G8 o- L操作：
/ S" c5 e  T% H  H6 o* \解释：
例子：
" K0 w+ D3 m5 W" S- p( x  o结果：
----------------
.
Match any one character
- g! X# k6 {3 o2 v- r& _" e+ ^9 Jgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
) _5 R9 m( Y4 T4 R( q! f! @-----------------
/ s& s- U, t: R8 l( i- g' r[ ]
Match any one character listed between the brackets
grep [cng]ord sample.txt
3 g/ N4 ]- a6 q5 t  S9 ^Will match only “cord”, “nord”, and “gord”
# i* g& R& Q/ N8 Q. f6 G: _% j---------------------
) f8 q; r. O" F% }/ n% m% [, j[^ ]
; T% c- G) }6 p  j* NMatch any one character not listed between the brackets

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
; [! _& L1 d5 |7 {* j
6 A/ |) d: [8 |- C& o( A8 \& ggrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

; m- r% b% R& d' Ugrep [^0-9]ord sample.txt
0 x: Y2 S* t  [, \" S' S) NWill match “Aord”, “aord”, etc. but not “2ord”, etc.

0 H$ @" H5 d7 F: i/ f重复操作符
  t" L0 m8 q' U8 `重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
- h; t/ c+ D6 G& z( ]! F---------------
操作：
解释：
例子：
3 J; d7 l& B$ ]0 A  B结果：
8 k+ c; b, q! P$ ]! o$ |0 ^----------------
5 \* C' L: P9 s; H?
9 \- d) u0 w; L/ IMatch any character one time, if it exists
* V* T( _; b7 T: u+ I* Aegrep “?erd” sample.txt
4 ^$ r' i8 Q3 O  CWill match “berd”, “herd”, etc. and “erd”
: }1 U; \& E4 j6 f- n9 ]6 f------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
+ Y/ a) i. D+ u1 b- f4 QWill match “nerd”, “nrd”, “neard”, etc.
! E% D7 L' Y$ u% f-------------------
+
. U: K$ S4 ]' h2 J; F  k5 ], tMatch declared element one or more times
egrep “[n]+erd” sample.txt
% }, R: o3 X9 j! Q9 e4 oWill match “nerd”, “nnerd”, etc., but not “erd”
+ I& z" |. p6 w) L--------------------
* I9 h' J/ n7 O& n; V{n}
7 N* Z: o" \- c2 X0 l) OMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
3 N) B$ U% g" N/ R0 uWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
% ^# }5 H6 |# P: k------------------------
{n,}
Match declared element at least n times
2 p) D0 K2 ]$ F& |' ]egrep “.{2,}erd” sample.txt
+ g. w& G1 I( ~: e9 E& x3 gWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
3 B8 A$ c2 B9 u5 `  O# ^* L{n,N}
Match declared element at least n times, but not more than N times
8 b" \, |2 B3 Q2 t- \egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
( a9 c' w, Z9 |6 q
第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

. q% {6 d1 h5 Y( x4 i* W9 gs/pattern_to_match/pattern_to_substitute/
0 e! F/ k" U/ Y0 V
  p9 z& R) E! q
" j  h% q& u0 I+ r6 w7 x7 W4 c9 z% a' STable C: Regular expression anchors
-------------
操作
解释
9 l# E6 ^) W  L4 E  B2 _8 ?" O6 s例子
结果
---------------
^
Match at the beginning of a line
# Y$ q" J( x* f/ u4 \- {# js/^/blah /
& v' W1 x7 K/ c3 ~% rInserts “blah “ at the beginning of the line
3 Q2 f# e* j% q4 r* |8 u4 p---------------
$
Match at the end of a line
3 }& Z0 R& f6 G7 \2 os/$/ blah/
Inserts “ blah” at the end of the line
8 T( G! s* Q; J3 k% p& A) F9 R---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
. h, {/ j6 W0 o) j3 A2 }" I+ q------------------
# \2 ^1 q# N6 x7 f* A1 d4 J2 v& [" B  H* k\>
Match at the end of a word
9 t, a- Y1 n- f& R, bs/\>/blah/
Inserts “blah” at the end of the word

2 t( A' ^: D" negrep “\>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
6 \* \' V2 p/ O7 X. h; Q6 }1 WMatch in the middle of a word
egrep “\Bblah” sample.txt
2 A6 \4 J4 A2 Y% R7 S8 CMatches “sublahper”, etc.
% @8 K9 j4 `' Y( [% p7 `. k5 T' p: x
间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
- o: T8 W9 @  |# d. \
) C8 f: l% d/ |+ H0 `8 xegrep “(n|m)erd” sample.txt

: K3 K' _. E) j; o. r% N4 c间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

. q/ z" R, t* U4 f) pegrep “[nm]erd” sample.txt

; g* \0 U* {; i( P( F0 f" r当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
8 z6 X' H4 b0 J----------------
3 [% I! r# I. n% Z2 w一些保留字符
5 T. W1 Z- T! qRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
. ?$ m7 t0 t- t( a: Y, R# X
* R6 [9 B& t$ A' ~/ c& C^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
* S4 n+ c) }6 n. m) (right parenthesis)
| (pipe)
$ A3 e4 S/ s% ~, Q' U* (asterisk)
+ (plus symbol)
5 n9 X) H* I3 Y, S+ z6 K? (question mark)
. w+ n6 H, k$ A( D{ (left curly bracket, or left brace)
\ backslash
" A( m9 G, E1 V4 ]9 v一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
, }, ~" u9 i+ e( ^; G; K1 {0 R
. [, d- j+ u+ l8 ^& V% N$ oeregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
5 E/ \) L) P0 }
1 f+ H) c& v6 V2 m, ]1 z5 Q你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
) U) _% `7 G) R! g0 V; B2 k7 P
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
  _  Z  M; _/ Z8 c( V, N# I8 O
另外一篇文章
----------------------------------------
) W' W2 ^" g8 z- X/ R正则表达式和Java编程语言
' h% n1 Z" {  R0 Q1 S-----------------------------------------
类和方法
5 q! C* w3 n  q3 N  C
3 h! p. ^, |- `; a! @9 i3 r5 F$ l: K& Y) F下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类

, R9 A0 q" S4 x2 D: D+ [Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
) Z0 v* p2 _8 ~6 T2 i/ {( w
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
5 F( _2 ?0 H+ u- e
8 X# G; Y! r. Y7 z8 t2 P' H: [用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
: V6 w  W! C1 G, a* f9 [
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
, K% O  B, T* o( g* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
# n& q: t% t7 uimport java.util.regex.*;

public class Splitter {
public static void main(String[] args) throws Exception {
1 p9 S6 r2 n+ S% `: a! \// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
5 t  N8 j. t) @2 }  `7 d4 V// Split input with the pattern
& n( J) ~6 m4 w2 eString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
}

Matcher类

/ K9 S, m$ ~) l3 u4 s% FMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
; Y* h+ ?2 U; y4 ^0 T# Z0 e: h6 d$ U: z
( K) h; {5 N0 r6 }  H% o通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
8 t  j" g9 g& ~/ ^. T6 H6 [4 y2 H
matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
0 i& r. G" @, K7 z& }0 Q
% O; \$ U$ ]/ }, u9 G% s2 t( }这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

2 |3 T" p# M8 P. y. r1 N+ j这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
+ @; a1 B+ A. m& C) G! p- ?
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
# `6 p5 m0 `8 n, h  l
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

- v" X3 v8 s/ _6 W; ~/ k  P  G! HCharSequence接口
1 G* _% q1 r2 ?- V: v$ Z
) i' w+ k6 |/ g5 @% Y" ?  B9 E) ZCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
5 b4 _' R; _5 g- V/ S# N; p( H7 Z/ m5 d
Regex情景范例

5 Q1 W! N4 K# E' D& w! z以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
, _% u0 z: h, D" p
/*
6 U8 e! Z9 a. }7 D& {. c" Z* This code writes "One dog, two dogs in the yard."
% z. ?2 P' p5 Q( R& \* to the standard-output stream:
! F. M: J  z# v, S*/
import java.util.regex.*;

public class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
0 j# B; _* L6 f$ Q8 d// Create a matcher with an input string
8 ?! V- i; b* Q: d$ B, _& xMatcher m = p.matcher("one cat," +
, `5 r; u) U+ d/ T: `$ L     " two cats in the yard");
9 o6 X$ u8 j# ]0 M3 e1 cStringBuffer sb = new StringBuffer();
5 z3 m; U: X  W: v% J& r3 c& Rboolean result = m.find();
% w, i4 f% b' [% W" C4 `// Loop through and create a new String
" J: o- S* b( a) |& }// with the replacements
while(result) {
3 D2 H, a5 Q# F4 k! p* Xm.appendReplacement(sb, "dog");
result = m.find();
% X3 D& M. L$ c0 u0 C}
// Add the last segment of input to
, ]+ X2 _: ~& Y// the new String
m.appendTail(sb);
. ~/ O+ Y$ n& J2 U. RSystem.out.println(sb.toString());
% A5 j2 X' b4 c" V}
7 S0 u! H( P. s7 c; f}

电子邮件确认
' X6 ~5 |6 p) a0 j  R
' I+ @6 D  Y8 Q: z" n9 I5 B以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
* |+ D2 W2 }. A) I
/*
* Checks for invalid characters
% @- q8 M, P  E, ~* in email addresses
*/
5 a( X' a8 C" O- p( V1 Rpublic class EmailValidation {
public static void main(String[] args)
' O1 i8 @0 i# Q           throws Exception {
           
String input = "@sun.com";
//Checks for email addresses starting with
+ _, b9 K$ u6 R- l//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
; V8 ]7 d) q4 k8 Y* B! vMatcher m = p.matcher(input);
) U$ G/ |8 |2 y+ K1 }if (m.find())
System.err.println("Email addresses don't start" +
% g( n/ O) E; s* G" f         " with dots or @ signs.");
) ^* c* t) m- j$ N8 k& l1 u//Checks for email addresses that start with
//www. and prints a message if it does.
8 T% G5 H" G' X! hp = Pattern.compile("^www\\.");
' m: Y, b7 L" C" ^! _) Am = p.matcher(input);
& P' m& J( e# b- Y4 u% C/ e! b! |if (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
: }* \0 [0 H. ~$ u; I3 j. _; Fp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
. d/ `7 ?& {* |2 W( J6 m6 {* TStringBuffer sb = new StringBuffer();
boolean result = m.find();
4 Q% P+ K& a6 N. _' Uboolean deletedIllegalChars = false;
$ c) O3 |  r  ^8 F' r# m
while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}
, N5 c5 n% E! k2 ^+ z
// Add the last segment of input to the new String
m.appendTail(sb);
( B9 v, y4 c4 M% |" h
/ Y7 t5 c3 X0 w! U; Winput = sb.toString();
/ q( x" E' h+ y0 @( U
1 t. U4 d5 e$ P. x5 Uif (deletedIllegalChars) {
1 ^1 A& O' Z5 x- q, {/ bSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
# V: m" A, v$ w}

从文件中删除控制字符
- i: O8 t' {5 t; G# L
/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;

$ D' l! n% t8 Y7 k6 ]  @, ^2 @! Wpublic class Control {
public static void main(String[] args)
           throws Exception {
           
3 Z; s& a+ @* ~4 W//Create a file object with the file name
" P: P9 @& Q. U. |- ]/ n2 W+ H//in the argument:
, [: K, N, I, YFile fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
( B9 `8 t* c4 N7 X1 zFileInputStream fis =
       new FileInputStream(fin);
# t1 X) p+ M: @) J" aFileOutputStream fos =
" E8 W& \7 _! E. c& v       new FileOutputStream(fout);
- d* I4 T4 q& W4 Y5 W: L
( k4 r' L6 N+ lBufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
- y/ r# w' n+ Y, a) V5 W' I4 VBufferedWriter out = new BufferedWriter(
! E6 L' Z& `/ M) N7 P) q     new OutputStreamWriter(fos));
$ m. B% f8 N: s# {5 @0 F4 Y
// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
! M% _) x  }$ c( Y  b6 s" zwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
, N& ^  }- |9 _//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
8 {+ q/ t  N% S9 o) z9 y1 ~1 L: m% s}
in.close();
2 @4 v4 ~9 U1 _8 R+ ^* L$ {* Aout.close();
3 M' ^* j, [" T  I}
}
& P7 @& o$ V- ]. t
+ E( P5 m, j; O# G* q文件查找
6 ^" a0 [9 ^9 z6 g) m
2 a0 i: M( y- E6 t6 i' A) T/ F/*
( c1 W* s% ?! q  v6 Q) [* Prints out the comments found in a .java file.
& K- a- U4 ?8 f& D: g! y" N/ ~*/
import java.util.regex.*;
4 J9 J5 v! b  Oimport java.io.*;
+ ]; D' b6 W% r+ r' ~import java.nio.*;
& @: h/ M/ m, Bimport java.nio.charset.*;
import java.nio.channels.*;
+ U" R& {$ b5 q  W$ u
public class CharBufferExample {
7 V' V. T+ [" t( I8 k3 ~/ k% @public static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
1 o# m- {  `: H$ [- D5 tPattern.compile("//.*$", Pattern.MULTILINE);
5 x8 |! ^) R- I8 t
// Get a Channel for the source file
File f = new File("Replacement.java");
3 ?5 `) c' W4 R6 e2 U# ]& mFileInputStream fis = new FileInputStream(f);
" X% J. f/ E) }" w" ZFileChannel fc = fis.getChannel();
2 E$ m9 T, V" z+ b" ]1 x
// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
& H- @4 I$ j7 M8 XCharset cs = Charset.forName("8859_1");
' P7 ?6 t% S4 e/ G+ {5 g. ~1 `CharsetDecoder cd = cs.newDecoder();
8 w1 s6 I8 M4 n8 `; yCharBuffer cb = cd.decode(bb);
3 G# c' `5 n5 @
2 }2 C3 K6 E$ C3 u// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
}

结论
8 ~3 C2 V& @* Q现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
2 M9 ^( h6 g$ b
9 h1 X& m" D1 r1 }JDK1.4之正規表示式
written by william chen(06/19/2002)

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

7 i# ^+ y2 x# D5 R" Y: O% a, a9 _什麼是正規表示式呢(Reqular Expressions)
7 d! Q7 U" L8 p
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
# D, T: W% d. G) J
8 |& q% ?& Z. R' U0 ^8 ^  \+ [3 C因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式
5 Q; s( T6 ~) @% W8 Z7 _3 v
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
2 l4 f# u  V9 ^) x" x7 S
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

# `  B9 s3 V: U2 Q9 E# H9 b3 R  Z剛剛列出的一串符號" s/
+ ]. U7 [- b' n適用於j2sdk1.4的正規語法

"." 代表任何字元

9 \7 l# t: {! o+ `! V# F- y正規式 原字串 符合之字串
. ab a
* K( J. q% S9 G9 I+ _5 N  G.. abc ab

$ G8 J3 @" M: g6 K3 z7 Y"+" 代表一個或以個以上的字元
  R0 J$ L+ S2 B3 K- N% u"*" 代表零個或是零個以上的字元

" B! h) {' q$ s' v正規式 原字串 符合之字串
, D+ s4 o( U' s9 l0 E0 J% _' H/ F+ ab ab
* abc abc

"( )"群組
) I) ~) F! }9 n" }% I1 w+ R. J# r
正規式 原字串 符合之字串
(ab)* aabab abab
# i2 {# k& S* X3 k  f  R
/ t9 `$ `3 a& K, F" y; Z2 ]& e' Y& L字元類
! Z0 Z8 C5 p( K  X. M, E  b# J
2 z  k* I3 \2 k. p5 U; g正規式 原字串 符合之字串
/ Q/ K% T" d- z! }[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
  r" l, _& B9 l8 d[a-d]* abcdefgh abab
7 k, M' b( G9 V. K

簡式

\d 等於 [0-9] 數字
* b) m7 F" m9 l) J! Z\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
$ j, e5 b% X* d' ~0 z! D- g\w 等於 [a-zA-Z_0-9] 數字或是英文字
  t, b$ h1 y) k2 v& y\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

( k" J2 h/ w) e( \, ]8 \5 F) x% D4 v^ 表示每行的開頭
$ 表示每行的結尾

$ `2 I. g, Z$ U3 V1 k--------------------------------------------------------------------------------
8 S- X$ d& h! G3 E) ^7 ~) E4 r. K
4 n% Z9 R& o# h2 k& B- R$ A% I正規表示式 java.util.regex 相關的類別

Pattern—正規表示式的類別
Matcher—經過正規化的結果
; r, K$ s0 |0 g; lPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

6 F$ E8 r) V9 I  H9 H範例1: 將字串中所有符合"<"的字元取代成"lt;"
4 u; o1 B5 ^, M- h5 Z1 i
import java.io.*;
9 S% |. z6 l. oimport java.util.regex.*;
8 e  `, s' t' l3 _/**
: x" |5 S$ x9 @+ U7 F/ @# g# S* [* 將字串中所有符合"<"的字元取代成"lt;"
5 [, a) j7 `8 v$ i" f*/
public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
& |/ ]5 W, F9 z$ J. v0 R0 A: yBufferedReader br = new BufferedReader( r );
6 X; U  D5 A6 n- R# x( nPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
5 Z7 \$ t% C) |( {& k5 X# `* T! \while (true) {
; O1 n) K/ U  \String line = br.readLine();
// Null line means input is exhausted
if (line==null)
6 A  n2 r  t$ K7 R& i! h  [) }break;
Matcher a = pattern.matcher(line);
! I% t' z1 Z/ K2 @3 I- Fwhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
& ~' \" Q5 j8 \8 B/ I/ v8 R, C3 O}catch(Exception ex){ex.printStackTrace();};
}
( b. \7 Q6 R' v. S8 o9 S* ?  \
範例2:
; w) T3 R) o# p* I- a3 ?# v
9 n% V* q7 u5 g1 i3 ^( C0 A$ L* g2 oimport java.io.*;
2 R/ }# E* V& ^  m, u) _import java.util.regex.*;
/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
7 `" v! a$ ~: _. w/ W. N// BufferedReader lets us read line-by-line
6 [- Q8 O. M$ hReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
+ i& B7 x5 l5 t2 K. Vtry{
' u' t( _- D/ s" ]6 K" fwhile (true) {
String line = br.readLine();
7 I8 f' \) `% L4 U; @String words[] = pattern.split(line);
// Null line means input is exhausted
5 [$ R. n5 N8 _2 iif (line==null)
break;
// -1 means we haven't found a word yet
int longest=-1;
# h; H: Q) g4 U- q: R) Tint longestLength=0;
0 I2 x: _: H6 Wfor (int i=0; iSystem.out.println("分段:" + words );
. }# ~' x) q  [2 d0 oif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
4 l6 |& Z3 p% A+ a9 D4 n8 N% @}
}
System.out.println( "長度最長為:" + words[longest] );
) _3 [8 ~) I0 V* n! J+ F* K% c}
, f7 p+ }  v6 ]+ c}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------
$ @! Z: A3 M; F: n5 f9 o
+ E# @( C- u( |; X' {  f$ U其他的正規語法

0 `9 O# m$ G4 ]  w# |2 d$ }/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水