关于正则表达式---ZT

Longe

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

, }0 Q& |2 f$ |0 l# e支持多种平台
3 G  S) R+ L" l" R
& M. l- V7 H5 W: _9 C& j9 p8 u
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
  \2 A% Z$ R8 h9 o
/ f6 e7 R( r2 j' ~! O正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
' }5 a* `/ F/ P9 y/ R) D0 K
5 ~) t/ f; C% g* k比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

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

第二部分：
$ g  l- r9 ]% y0 Y& `----------------------
- g# e/ ^& \* W) J字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
/ G  z9 L! {" n& Z4 f3 C
! ~% ]8 c7 }2 R5 O每一个表达式都包含需要查找的指令，如表A所示。

Table A: Character-matching regular expressions
格式说明：
---------------
" W: `9 v/ W( s; j9 w4 L7 a操作：
解释：
* G: o2 F# @/ X8 q/ X0 d+ M例子：
' M; |3 {/ X% e4 ]( r2 [$ H1 h# c结果：
3 M9 `! w5 v' C! M3 Z% ~6 X----------------
.
* N- M7 G) {: D, bMatch any one character
7 Y. V4 |( g4 K0 Agrep .ord sample.txt
4 D" @2 e: W- O0 s6 I2 c7 o- R6 |) uWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
* b' n+ C2 N* o" y) |  l3 g2 hMatch any one character listed between the brackets
  Y) B3 n; A; U% Ygrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
5 S/ G, p$ h( H---------------------
" \  v. f% L2 E' M0 v5 u% k2 M: d) A[^ ]
Match any one character not listed between the brackets

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
; s1 w4 W! u$ g. x$ D% f% F7 w
+ e2 f* x3 w" Cgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

0 G  h- G; V# u+ q6 F+ ngrep [^0-9]ord sample.txt
# E/ e: L3 [7 ?( T+ GWill match “Aord”, “aord”, etc. but not “2ord”, etc.

, D) H( @2 I8 b# d4 P重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

0 w$ f# N) I1 E: a- B, HTable B: Regular expression repetition operators
格式说明：
---------------
) t* x4 n$ k3 {, F操作：
* @" ^) W2 ~) O$ l' s解释：
例子：
结果：
/ e. e. {! R- s: B. [----------------
: \& L# P& W. U: d8 u$ h?
Match any character one time, if it exists
egrep “?erd” sample.txt
% Z: O6 P5 Q0 }# i+ r0 U4 [Will match “berd”, “herd”, etc. and “erd”
. |, L4 R: x7 n7 B2 f% f------------------
*
Match declared element multiple times, if it exists
; l. M, `: Y6 C( p: p2 Begrep “n.*rd” sample.txt
$ z+ k) i8 l* q# Z8 @/ r" JWill match “nerd”, “nrd”, “neard”, etc.
2 a5 I/ K# g9 F. [5 f3 O-------------------
- G, Z  r2 K9 X1 u3 [# `+
* N% H- v8 h8 L+ y1 r# ?, mMatch declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
9 t0 @" L' r) S6 w--------------------
& s- s  o: _* e) t% J) P{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
( s0 @* U% A( E9 m: QWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
  J" E+ v; l9 D4 I- v, D  f! h------------------------
( Q5 @' v: X% l2 z, g8 ]7 ?0 w! Z1 ^( ?{n,}
Match declared element at least n times
6 ?) j4 h" p* q# p3 m- Jegrep “.{2,}erd” sample.txt
( Y3 s/ ^1 N9 s2 z8 w& o/ a- M8 vWill match “cherd” and “buzzerd”, but not “nerd”
8 w& x% u' O" Y& K0 T/ A------------------------
4 j1 \- H. T- u0 s! d" W8 U9 M{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
( W( `, s$ ~) nWill match “nerd” and “neerd”

第三部分：
7 _( q0 }6 \$ Q----------------
" s: o( ~- c) X! J# ~% d锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
& \& i  _# A1 |# I! L0 f9 r  T7 d
s/pattern_to_match/pattern_to_substitute/
2 {. ]+ `) t! t% `2 a' c
9 U6 F( H& e2 C. K
Table C: Regular expression anchors
8 |/ {( K) Z6 |) f* ?-------------
操作
8 i* l! n9 M! ?1 [; F/ t解释
6 ?: k9 \7 M4 `& h2 k例子
8 y( H$ |8 @# O结果
---------------
0 h5 r: \0 R: N^
% n% _' Q# P! @7 Q$ ~4 T' cMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
8 l- i0 r" ?, Z: m$
  R. J  j/ i6 F& O. OMatch at the end of a line
# x  |1 Q1 u( u5 D) A1 ~s/$/ blah/
Inserts “ blah” at the end of the line
, m; \7 s7 |/ i0 n---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word

  h3 D$ w$ O6 K8 W+ `) K2 s8 cegrep “\Matches “blahfield”, etc.
  b0 E' G  S) z5 M9 o. a0 G' A------------------
6 Q' n8 G. T4 ?: ~* l2 \\>
8 N; n6 t2 i3 \9 G# s/ JMatch at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
5 g; x  T5 r/ R' h6 G- }
* U! w/ W& Y7 \! S0 e1 _& Eegrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
\b
, u$ E$ p8 y6 q; l: R* \Match at the beginning or end of a word
egrep “\bblah” sample.txt
% l/ J+ S, F8 ~" B4 cMatches “blahcake” and “countblah”
-----------------
\B
9 s7 b  n! }1 r, T( y& ^Match in the middle of a word
egrep “\Bblah” sample.txt
4 ]( _6 _7 N- j4 S, ^0 j$ e* M, fMatches “sublahper”, etc.
4 [/ i1 u- t! M8 a- V( b
间隔

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

( v/ c' H7 J3 Xegrep “(n|m)erd” sample.txt
* z" K" V% Q- {4 ^' G( M
) \3 y4 Z% L- R# i间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
; Y/ y" s( Y* X" s1 e
; q* N; y  U( i2 Fegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
3 I' n  T  N2 M. @4 h
第四部分：
----------------
% h+ C) I2 @. @5 K/ g! |! t% p一些保留字符
5 H9 a" E/ m1 M1 \Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
; j; j! I8 y" j# A9 S8 i, Y
^ (carat)
. (period)
" R# y% C  B9 f" M6 J7 O[ (left bracket}
2 p. M! v4 x, E0 L, a( ]5 ~1 ^! g$ (dollar sign)
% ?- f7 K7 ?6 t( b8 A( (left parenthesis)
# {; a+ ^) J( C$ d) (right parenthesis)
| (pipe)
+ E+ u8 G- S* k* (asterisk)
0 w  [- Y- q0 i' D2 V4 F( H/ k+ (plus symbol)
? (question mark)
0 x9 g8 v6 i! t& h{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
6 f8 O8 r5 Z# p9 l% v
" V- b$ b$ ^3 a6 Q你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
& B' {% ]1 v9 O4 O
" O( ^8 E3 V$ x$ W, y总结
8 ?) o- t$ [' f6 [$ q1 h8 P% q4 u% o在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
. G* B) i( j7 e' N5 e----------------------------------------
' B# _# x, p+ G* I/ }7 W正则表达式和Java编程语言
6 T! h0 j* Y6 N-----------------------------------------
( f; @$ g1 H( k/ [类和方法
- n& G7 u5 @3 x. [9 p5 j
, Q* b3 i4 U$ x5 A. A4 b下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
9 v& I/ P* t  I$ g( H7 d. W
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
1 ?: z; L$ |3 [1 F6 Y: u
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
  c2 ?, p: Q7 E9 k6 q$ f0 J  p6 r
6 `& H' [# t( ^; Hsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
& s) y/ V' y3 E8 R, M4 q*/
, F) a6 x& R4 p9 Oimport java.util.regex.*;
( V- I5 t/ ^- j
0 m0 s! t- h& l$ ~) Upublic class Splitter {
6 ]2 o: X2 |0 J) A) X6 f( `public static void main(String[] args) throws Exception {
. N0 C5 |, f/ L$ x// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
- a, [( V: V% M* [9 w' tString[] result =
) C! j* `/ ^% \% l) b7 _0 U' o   p.split("one,two, three four , five");
3 j; Y$ _" w- n9 K1 wfor (int i=0; iSystem.out.println(result);
}
7 M. X& Q* {: P# q: r9 m: K}

5 t6 ^6 J7 n7 j# {' f5 f. sMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

1 k5 V% x2 [9 g! O通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
' X& T6 S+ `0 z0 f+ e9 S. z5 m. alookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
% {. K( E/ R0 e' ^) }find方法将扫描输入序列，寻找下一个与模式匹配的地方。
4 w  F8 }" |1 r/ w- n; Q' T
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
7 f5 h, g+ e, m* ^" N6 D8 a( P
' L' ~4 H8 {! I9 o' G" p. R9 A这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
- H3 ^3 b0 G0 L  j) T/ L
$ _- E( c: v7 W! M. ]* s& x( happendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

8 v# K1 c0 g9 |1 @( C+ S例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

, \/ a) j% Q- c( z! |: ^CharSequence接口

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

Regex情景范例

2 @" _4 o9 ~- t& J4 }) ?! {以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
  x, ], S6 W; @
+ _# w; V7 ]8 Y& b简单的单词替换
# H" ]" {% S- L$ M0 ~5 Y7 e; R4 U1 n
/*
# p- Z, H$ u: r- M" D; k$ l* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
5 c0 H4 B" E( u*/
7 I. N) _3 N$ e6 c0 J2 \import java.util.regex.*;
+ k6 d0 O4 Y* A. ^- p% w/ _2 }
7 n( k. O" F( D. Q8 u1 b4 I/ apublic class Replacement {
public static void main(String[] args)
       throws Exception {
) E3 o2 G- _+ H// Create a pattern to match cat
1 ]4 O6 g! ]$ }4 \1 W5 G5 sPattern p = Pattern.compile("cat");
9 H2 I2 P4 S* e- A: }# A" w// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
: x5 A1 w) t4 H     " two cats in the yard");
StringBuffer sb = new StringBuffer();
3 v# r# g; A$ `5 B. A1 Iboolean result = m.find();
// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
6 Z8 n5 I2 l1 o. o3 ^' \. J}
// Add the last segment of input to
// the new String
+ \; d$ A# {5 C0 f; E' ]" Am.appendTail(sb);
System.out.println(sb.toString());
- T/ |9 ~* ^- P}
) m* k' g) d8 P}

电子邮件确认
; x8 _0 y+ Y$ Q( C8 O9 D5 G0 K  T( [
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

  ~4 D0 K6 O9 Q% X9 J/*
* Checks for invalid characters
2 z/ @8 a* m- p* in email addresses
*/
4 \2 e0 k/ p9 U" J: x7 Q$ Q" `5 Wpublic class EmailValidation {
public static void main(String[] args)
1 A: v1 N" A5 y" o) B           throws Exception {
           
% [$ ^7 B" j3 Q, BString input = "@sun.com";
% e9 q. {. V) z//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
2 K' \4 O6 u9 i6 x# Z$ X/ v; KPattern p = Pattern.compile("^\\.|^\\@");
; p: t0 I( d( x/ G" d" u4 xMatcher m = p.matcher(input);
* d$ Z; o+ w. Z/ P% f' Yif (m.find())
System.err.println("Email addresses don't start" +
: Q2 ~5 F4 O% \8 w2 Q5 M5 Q" @         " with dots or @ signs.");
3 F9 G8 E- i8 V$ p8 k( `//Checks for email addresses that start with
//www. and prints a message if it does.
" U6 l6 I( @2 \# I3 v  Up = Pattern.compile("^www\\.");
, \4 o' m5 ?2 m0 _9 `+ N6 S6 m: T5 Pm = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
) H( J% t8 L" ^/ E}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
8 @2 ?' N/ ^: um = p.matcher(input);
! R( e/ p5 U$ \StringBuffer sb = new StringBuffer();
# @: c  i6 v* _7 B- V$ yboolean result = m.find();
# V9 u; d6 u5 t6 R/ gboolean deletedIllegalChars = false;

while(result) {
deletedIllegalChars = true;
& `% V9 O; ~2 ]4 em.appendReplacement(sb, "");
! Y2 S* r/ \2 G& h9 C" sresult = m.find();
8 T) S) U/ Y  T4 b1 b; |% x% Q}
  T% }* U% f8 u5 g/ B9 ?
! S5 `% r+ U: ^& z// Add the last segment of input to the new String
, f" Y8 C; |! F! ?$ ?; Om.appendTail(sb);
2 u: V/ p+ g. _& ]/ v+ t
input = sb.toString();
/ Y# c" m) H) k8 B  D
if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
6 H7 j8 ?1 [* ^( B, c. x}
}
}
& N) Q; `% f8 O* i4 o  N+ H
$ T  o5 C; A/ `! h2 t& k从文件中删除控制字符

& w$ g3 ]( e4 N/* This class removes control characters from a named
* file.
! ~; ^  X# O1 S# S3 ?7 _" d*/
1 o5 r; h8 Q4 x7 N1 Z2 F0 Timport java.util.regex.*;
import java.io.*;
; ^+ Q1 L  `- ^; I+ `3 m  n
public class Control {
public static void main(String[] args)
           throws Exception {
: Q; |7 z+ j- M2 s8 x5 L7 _           
$ ?  t5 n6 e1 K" ?//Create a file object with the file name
2 l* F; Z% W6 @6 e//in the argument:
; U( q( N: R, w& K6 `File fin = new File("fileName1");
# w' C( y# U7 r$ H% e1 PFile fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
6 Q4 X  t' z! [+ C! M  pFileOutputStream fos =
       new FileOutputStream(fout);
! X' z" ~' q% }3 C
BufferedReader in = new BufferedReader(
1 r, K0 R$ |' e' b3 T' r     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

// The pattern matches control characters
- T( _6 [0 B+ `! Z( o7 dPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
& A8 i( @8 y( q+ r  `. u' ZString aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
/ Z6 U; B* V1 i  V2 p* }3 H//Replaces control characters with an empty
4 u2 ?; G0 O+ S8 x  _//string.
6 b8 }, B! k. ?6 \) _% I( `$ ?7 Y7 OString result = m.replaceAll("");
: S# D# j. S0 Iout.write(result);
4 p& ^/ r* @/ r9 j. c8 z/ u$ Wout.newLine();
- O, B5 ?# N7 n% a5 ]  t0 F- L}
in.close();
out.close();
; Y3 }# y& z# a7 X$ Z2 [; |}
8 r& w9 b4 W" r- R}

文件查找
4 Y3 ?: N9 z+ ~2 K( O
: w7 s$ s1 R. m/*
* Prints out the comments found in a .java file.
*/
8 V  t# r8 u) ?) X2 l. z& Z( y" kimport java.util.regex.*;
: d! ]( Z' M* M# [9 Q$ s5 O1 |% Iimport java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

- W. S6 X! ?& h- ?7 y3 V& k$ Apublic class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
- m! ?8 J" D4 K# ]Pattern p =
* s3 f% K+ U% v4 O; Q- v3 RPattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
, o+ y! \0 a2 AFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
0 u: ~" D. ]7 j& g- P8 o
8 K. G- w1 L- D( h8 q// Get a CharBuffer from the source file
5 j! X' l- `; ^2 K7 g0 W. }& [+ QByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
5 V/ O' L3 z! X2 U+ r
& _5 ^& B7 l3 g// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
$ g$ [2 S8 ^1 H0 \$ Q: \}
}
; c! x! o: N. c
6 m4 @4 f* |' M5 j; \结论
" I4 X* J0 y/ X9 Z6 j  F现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
$ M; x6 s/ F: N' g$ {) _
JDK1.4之正規表示式
written by william chen(06/19/2002)

: f7 s5 U+ r  n, H8 W; L( V--------------------------------------------------------------------------------
- O# j! W; Y) w6 P
什麼是正規表示式呢(Reqular Expressions)

4 y. `2 L" T8 ~& F  J6 Z: {就是針對檔案、字串，透過一種很特別的表示式來作search與replace

5 T" S  R$ |( ^! E! q1 [7 t6 _因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
; A5 V& D! n) C* F3 c+ N
2 T' G5 y0 b- y所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
; ~  V0 S2 B9 s, W. N
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
" g' n' f8 c" G: I% x
' J' f7 z! A& p% h# o- C剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

"." 代表任何字元
# c9 p. B* T* `2 e9 y: T+ z
正規式 原字串 符合之字串
. ab a
! _: K! t7 a, D6 M% J! \/ t+ g.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
$ w) M8 r; H- d' E
; O+ c, e0 D- e2 T1 T正規式 原字串 符合之字串
+ ab ab
* abc abc

/ X) m9 I, d% z! e2 v* `) o. M"( )"群組
4 l$ d- _/ I' ]/ x. F2 K6 R
% X2 O+ U2 W  M2 \: H正規式 原字串 符合之字串
* s; I5 [3 \; M" g9 X+ P(ab)* aabab abab
; q3 [4 Z9 \. n8 \! L' K
字元類

正規式 原字串 符合之字串
" P3 z( m: R* H3 `[a-dA-D0-9]* abczA0 abcA0
/ g! _7 f8 k; h[^a-d]* abe0 e0
[a-d]* abcdefgh abab

0 J6 q7 v# ^% t( l. z4 t, U7 Y' U' ~
0 ]" q6 n" s0 }簡式
- A5 w  d3 s3 ^# u$ _) d
\d 等於 [0-9] 數字
# k9 q, g2 V2 k! F  k7 Y& X' M\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
* G: w/ X4 C4 @; ~  y/ K* M\W 等於 [^a-zA-Z_0-9] 非數字與英文字
! [; v% ?  U' b8 _5 x$ u$ I+ V4 U/ a) o: L
每一行的開頭或結尾
- v! D/ G( ]& i
' w$ R( w" S; x' O9 d" u9 O2 ?^ 表示每行的開頭
$ 表示每行的結尾
- i7 A9 o/ P& _
5 ]( p8 d' I( ~+ f--------------------------------------------------------------------------------

. F1 c6 h# S7 q/ `  [# {正規表示式 java.util.regex 相關的類別
* @; o. O' O; ]4 V
7 l$ z9 ?5 B+ `' aPattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
: G7 q1 d6 J; V1 {0 q5 T8 u% G& I
範例1: 將字串中所有符合"<"的字元取代成"lt;"
2 Y1 q$ X; y# @8 z
import java.io.*;
/ q; H1 ]: Z* ^" H$ oimport java.util.regex.*;
- ~( ~$ m# l  U- ]' v+ V7 }/**
$ ~6 g; J0 S2 e/ P* 將字串中所有符合"<"的字元取代成"lt;"
6 D6 Z: i) o4 I7 K*/
public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
; \- D" B1 H! m& i5 Btry{
while (true) {
$ _: E$ e( a2 _  F( X) sString line = br.readLine();
, j2 f: L, B  _) o. H// Null line means input is exhausted
if (line==null)
& J' e% z/ x4 G# q, u' v0 bbreak;
- ^4 ]" a  Z; S/ c: GMatcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
0 o% J. {! X2 L( }) u% M- ^0 q- Y2 X3 b0 u}
}catch(Exception ex){ex.printStackTrace();};
}
) l6 e  J: p5 {9 M$ n; ]0 ]
範例2:

! M7 P6 p" {4 d0 K7 \import java.io.*;
import java.util.regex.*;
4 w+ T0 T0 J- p. P3 U/**
$ q. c$ c. N1 L5 `4 `4 W( t4 Y* 類似StringTokenizer的功能
; z5 ]& W8 y1 }+ C, Y( {7 D* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
! x; X$ @2 O; K' b; e/ y// BufferedReader lets us read line-by-line
0 Q  u6 \3 w/ R1 C! WReader r = new InputStreamReader( System.in );
$ x8 h" ~: [& z0 `: n; w  O  E1 `BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
0 e" Z7 e  [, J) Q* U$ W5 ~, A3 qtry{
9 X$ L+ N3 ?0 m4 uwhile (true) {
String line = br.readLine();
# R( }) K% X. l1 `& D+ F% I7 aString words[] = pattern.split(line);
// Null line means input is exhausted
/ t' m7 d1 ^2 O1 e, Y8 vif (line==null)
) Q) s& }' u( p1 }8 A6 {( rbreak;
// -1 means we haven't found a word yet
! K- `  l! K' Iint longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
% ^4 A- ~! ^) Y0 t! ylongest = i;
longestLength = words.length();
% ~5 a; p" y3 V. b- E3 c}
}
System.out.println( "長度最長為:" + words[longest] );
8 u/ S0 H. K+ ~3 R$ i" c}
}catch(Exception ex){ex.printStackTrace();};
}
1 h. J" E# f7 F6 U5 Y- C
5 |/ R; Q3 g$ B8 ?; Z--------------------------------------------------------------------------------

其他的正規語法

/^\s* # 忽略每行開始的空白字元
5 P2 w. e- G- \5 k" \) O(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水