关于正则表达式---ZT

Longe

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

支持多种平台
* j: c/ M3 V8 N9 d0 Z- U
( H" U% u; @: B) w+ X
! _$ i0 j! {" g7 f! r5 E正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
7 V' x3 s/ p; u& w* v+ ]; H
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

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

* B. a" C. m# y& V( {正则表达式101
/ S+ C* j# Q4 H! `很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
( F; e- E. |7 c  S. O+ }
第二部分：
3 @) w) h% T! m( v( S+ a" F% Q----------------------
字符匹配
# |  C- ]( D$ E7 B
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

每一个表达式都包含需要查找的指令，如表A所示。
, s8 q" q( b) c/ w
Table A: Character-matching regular expressions
; H+ G) t# z$ s/ Q& _; c: x5 x( F3 a格式说明：
---------------
8 ?: z" N3 s- [- i$ g; e* G+ P操作：
( R4 f! W$ C; ^  ~" P解释：
$ N. n7 A8 K; V( n1 x$ Z例子：
7 ~/ a. c, h% I. {1 |8 n结果：
----------------
.
7 o2 n5 \  y" m% P/ kMatch any one character
% q  v( ~. Q) h+ ^& @grep .ord sample.txt
: F5 ]5 F, V; o4 y) xWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
6 K9 h) r% y6 t/ ]4 V* n! N* Y-----------------
: i  G: ^3 X. Q) F7 s2 Z[ ]
Match any one character listed between the brackets
grep [cng]ord sample.txt
6 @1 V* A3 Q% j- B8 L; z% d1 aWill match only “cord”, “nord”, and “gord”
---------------------
+ ]. c; \0 P8 q[^ ]
Match any one character not listed between the brackets

+ J3 s0 N1 R% O) C. d- zgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
$ f  |2 y. V5 Z  v2 }, V7 }
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.

重复操作符
! @/ K0 b2 o# h8 O重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
" w0 i5 @' g" Z/ J2 J
Table B: Regular expression repetition operators
格式说明：
+ Q6 N& i7 c8 |% J/ h5 f* D! F---------------
7 o% o8 W" D" v9 t操作：
' [3 \0 G  h! M. C解释：
* p" {- {5 v* ]* C4 s5 {* Y, e例子：
结果：
7 x. x1 E: J% n3 X4 e0 C+ P----------------
?
Match any character one time, if it exists
( V. l4 J, P' _* V" X5 m1 begrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
" ]9 x4 m) X% y0 `! g------------------
- L5 D& N/ y( P  R*
- F/ s4 y; o! J! s3 C$ q) bMatch declared element multiple times, if it exists
+ l+ E* D" y5 X" B/ I$ legrep “n.*rd” sample.txt
) J( W6 i! {6 H/ q( ^Will match “nerd”, “nrd”, “neard”, etc.
-------------------
( i1 g/ ?( M* ^  W  h3 O2 i0 c  g+
Match declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
+ s- d% G; W) i; |2 U" rMatch 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”
------------------------
8 E* d3 {8 z& E/ G{n,N}
Match declared element at least n times, but not more than N times
: C0 w, X: g4 uegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
+ p$ V! I+ O0 U, ]
' l5 F8 k( F& V. T! v) K第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/
1 G1 Q# C- h. {; T
2 ?; m8 S) Y# Z7 X1 L$ E
, {, Y$ {) q2 T/ ~Table C: Regular expression anchors
7 q  U" n) Q9 ]-------------
) I. e3 y' {+ l: o操作
, B" j6 t8 ^0 n4 W1 _3 o: y解释
; b) D0 _+ h+ Y0 p+ B例子
结果
0 t4 r% X' f% f---------------
^
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/
, y* j3 e) `% ?6 jInserts “ blah” at the end of the line
- ]6 c9 e. M$ B2 o* M0 _---------------
\<
Match at the beginning of a word
5 ~% G' w- w# n1 R5 Xs/\Inserts “blah” at the beginning of the word
2 f" T( o) C8 G5 f% t$ j) o
egrep “\Matches “blahfield”, etc.
------------------
\>
Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
1 C3 g3 }4 V+ O# j+ R
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
$ T6 ~% e( B/ ~# p' Y3 v---------------
3 r4 c: }3 K1 l- I" F: d! z\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
: o$ c# {' G& ]- @0 r) u-----------------
% M; N; b3 U$ t/ T\B
( d. ^7 [- ^& d' h$ V4 c3 L1 b  BMatch in the middle of a word
* ?' _. a( i5 W( A4 n5 cegrep “\Bblah” sample.txt
Matches “sublahper”, etc.

! |( ?& e$ m, ?- K间隔

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

/ i* `+ ]8 o( O) M% a# g9 Iegrep “(n|m)erd” sample.txt

; F% b0 b' `/ f( t6 V. J间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt
: ?( S7 b0 s+ P  @2 n2 X6 F
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
1 u: T; t3 Y. _% l" `5 r8 A8 g
第四部分：
6 P! m: Y, J5 ]- ^----------------
6 h" N. D' U; t. H" k; w& A. a, w一些保留字符
9 O; `/ o. p& |1 |3 ~Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

. z& e6 a/ ~# m: }^ (carat)
# X5 ?6 f- C& ?# h5 d4 p- t. (period)
/ i8 w0 C) g- F1 O6 e- P[ (left bracket}
$ (dollar sign)
# N' Z! K) l* |2 E. `  I# ^( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
$ j' c: _+ `& r% y6 J+ (plus symbol)
? (question mark)
: `4 l5 L: r0 H% c( l: G{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
8 r$ P5 s8 V6 @# ?
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

' S% F, r& [6 v9 d8 O你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
. q- ^# Z+ c) D6 n
总结
; f5 J, j% X4 R在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
7 w- e% F) ]3 I, u, u" g5 t$ t( L$ l----------------------------------------
正则表达式和Java编程语言
0 }0 s, _- m1 b, f-----------------------------------------
6 D/ f' K2 r0 D0 T" y4 K/ k" y8 l类和方法

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

" W9 K7 r* n. O, L" J/ c2 ?Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
6 Q* \% V0 S) k  [% w& C$ U
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

% _7 n2 Z" z# B0 x6 E9 |, `# Z- w用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

+ S, ]4 G( e0 d6 q7 psplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
7 `: R- t( i- d9 m5 Q6 {
/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
$ S+ y/ P9 s6 j*/
% B* w$ s' l, u  M  [" p# Mimport java.util.regex.*;
. {5 b1 c1 w5 q7 }! ]
public class Splitter {
public static void main(String[] args) throws Exception {
+ G. y3 u8 s$ o/ _5 O9 u! P' P// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
, J/ J& e/ V7 C6 `) C* ~8 i1 a// Split input with the pattern
String[] result =
4 i- r3 f5 |/ @: U   p.split("one,two, three four , five");
% Z6 [0 e$ o. sfor (int i=0; iSystem.out.println(result);
}
}

Matcher类
2 @8 H0 B" L) U5 s3 m8 C) j6 _' B) I
( n. B( `% ?. K5 K: ~% pMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
8 l: G- C9 s. T$ Q9 \+ b; T
( @" E8 X! r! A通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
6 J3 E$ K% G8 v; G) g. f$ e
1 t" k' \7 L' Z, N! k! P- Wmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
7 n% w8 O2 t4 J, ~7 G/ tfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

) |7 M, _/ ^; a+ v; I# l这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
9 E5 c6 {3 B/ i# u) g7 c
! T" v% K% X) }: d& B* e! z! W( ~这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
5 G1 C1 f$ k( u  o8 S3 O
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
% i/ x5 S  i' M$ r' J
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
$ E# _8 B" I4 I8 b  \# E, g9 ~/ f# F
) p% a+ F8 V, nCharSequence接口
& w0 i2 v2 R3 B- J& v- Q
5 W1 [6 ?# P3 _  e3 Z7 c) pCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
( ?* I8 g8 d. @: o* k8 D- M) U7 f
Regex情景范例

5 t  R# M, _. ]9 u以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

, W+ |7 X/ X4 b  n% |* }) t简单的单词替换

/ W" g- o- C" Y' v1 t1 P: W+ l/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;

7 Y& D( z1 M) K+ K0 t! Ipublic class Replacement {
public static void main(String[] args)
. S: A: Y7 U# x1 F1 r% p       throws Exception {
3 i8 S! i4 @7 D+ L+ u" R// Create a pattern to match cat
2 z0 ^' A( s6 X, m! cPattern p = Pattern.compile("cat");
// Create a matcher with an input string
# ?$ l9 O/ u$ l, S1 Y7 i  cMatcher m = p.matcher("one cat," +
     " two cats in the yard");
% o0 z. b6 S* G; k( d  Q6 O. EStringBuffer sb = new StringBuffer();
boolean result = m.find();
; h% g" l3 L( z  s% ^' s// Loop through and create a new String
" q  Z) L; W# G, R9 M% |// with the replacements
+ R+ ^) h3 b$ U& @. j7 Wwhile(result) {
% q2 |; m' W' X( q/ em.appendReplacement(sb, "dog");
: X) Y) Y8 W- \- Hresult = m.find();
) m- y0 P/ }8 q}
// Add the last segment of input to
. g8 \+ \7 b2 B8 R// the new String
+ d4 t5 F& {9 E$ Cm.appendTail(sb);
System.out.println(sb.toString());
}
}
5 Q$ l2 L0 v: U
) d- e( {: u6 E! [电子邮件确认
3 J: Y. G+ g# ^5 Y3 R
" c& t4 G* h8 g/ v2 K+ P' g& V以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

" L( e# Q- J; N. U7 e! O( S; X/*
* Checks for invalid characters
* in email addresses
*/
% T" J- F$ u5 q' apublic class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
7 p, T9 p( `) Q3 k' r3 M0 ZString input = "@sun.com";
( T- r) M! G3 g( H: w% z/ ?) M//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
3 Q( J3 m" y9 _9 t6 h6 KPattern p = Pattern.compile("^\\.|^\\@");
; O- S) K6 ?5 g! R3 VMatcher m = p.matcher(input);
* O1 ^7 X0 E. Hif (m.find())
System.err.println("Email addresses don't start" +
( ?3 N, A4 @: h) Z         " with dots or @ signs.");
//Checks for email addresses that start with
0 v+ o1 }3 O9 X: X0 Y+ g//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
1 E; p! \0 S' N) o6 [7 vSystem.out.println("Email addresses don't start" +
  r  u; z; D7 V5 X/ q& ~; s2 K+ k   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
- W0 X* l5 k5 b% Z( Hboolean result = m.find();
- c6 G$ [2 A7 K, Z, V0 I0 cboolean deletedIllegalChars = false;
8 w0 O; Z( Z1 X! S/ W" a
while(result) {
deletedIllegalChars = true;
+ \* ?& H9 R$ T1 lm.appendReplacement(sb, "");
# p# Y( r3 J- t2 m- z' S( v: Eresult = m.find();
}
$ E& r5 x+ P7 f  R" f& L
- H& }- q: T, P: I9 |4 P4 O$ [2 \// Add the last segment of input to the new String
m.appendTail(sb);
2 L. j; J  [  D6 k- {6 B" o% U
" \2 O+ t, S  Y6 ainput = sb.toString();

if (deletedIllegalChars) {
+ o( o1 M2 m& S# r4 ?System.out.println("It contained incorrect characters" +
6 A. K1 E/ t6 c7 h       " , such as spaces or commas.");
+ `* }5 S" `# `9 F1 Z}
}
}

从文件中删除控制字符
! s( n1 D- d- u  Z+ L" }
/* This class removes control characters from a named
* file.
+ Y5 A0 W4 h( {& Z% U8 L1 n3 U*/
import java.util.regex.*;
" R/ V4 N3 S  q, U, l( t6 k* R. }import java.io.*;
1 ?# [, R) G) b, [* ^* D
; {- K1 K! f& @! A% Npublic class Control {
public static void main(String[] args)
           throws Exception {
/ c; S6 ^; a, T6 n" I+ H( F/ P           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
9 N; {1 Y) i8 \* q/ yFileOutputStream fos =
7 w; X# m7 @  s: w/ c4 W9 ~       new FileOutputStream(fout);

( u( ~% L; p+ Y3 _4 v( cBufferedReader in = new BufferedReader(
, L0 W8 k7 H: l3 K) ?     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
# D' O2 q% B# L! k' ^1 D5 I# Z     new OutputStreamWriter(fos));
) S8 ^, @- H" G' z2 B
8 q; ?/ X# w7 {8 j8 h/ {, M6 L# Y// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
3 f3 O! T+ t: E$ S0 O2 AMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
$ u4 b' ~; m, C5 F2 ZString result = m.replaceAll("");
out.write(result);
out.newLine();
2 w) Y5 i9 X# w5 t1 ^}
in.close();
  R! p7 _3 x2 E, |" U1 ]* X% {, Kout.close();
9 f, w! B- S% n3 U( g' T7 a! m2 i}
}
& Y7 k; K( _1 Z2 w- [' z" n
  F% G- q1 T! h  J9 p9 b. `% Y文件查找
+ }9 e" U6 J" E. d
" c% Q. d: x# b/*
* Prints out the comments found in a .java file.
" \% ~- D/ p$ w* t) e: W/ M*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
. @  B1 e) r  K: @import java.nio.charset.*;
import java.nio.channels.*;
0 h; q; y, Z3 s, L8 ?' @% W' I% [
  ?' V! Q' G: B; l% Ipublic class CharBufferExample {
public static void main(String[] args) throws Exception {
7 q8 a# ]6 i8 z" R7 B6 G  k// Create a pattern to match comments
, s7 R# w  k# x. SPattern p =
9 Q, m# ~" d! H5 M) N; i# DPattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
. b& ^7 E1 g3 h6 J1 l0 O- sFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
/ ?/ @4 G! |. @FileChannel fc = fis.getChannel();
7 u' t4 U! b: _
// Get a CharBuffer from the source file
ByteBuffer bb =
& B& c* x; W! m2 E2 T5 ffc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
7 j* J5 B$ f8 [* Y) ?$ C' ?- Q6 jCharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
9 h  h" E% |# G: {6 S. ?9 n; m}
}
& C" u9 |  `' r; g
结论
  o, l$ t# d# y现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
written by william chen(06/19/2002)
! ?% [8 J8 p4 O* `- C0 U7 B' s
- W1 K5 T( e" ~4 [5 X, t--------------------------------------------------------------------------------
3 Y& l# r& K" _9 F" B
* A; _: o2 e7 S& a什麼是正規表示式呢(Reqular Expressions)
" V+ R% E: R! V, o9 ^4 ?
) m$ M/ [8 _7 ?1 Z( m3 p就是針對檔案、字串，透過一種很特別的表示式來作search與replace
' Q+ M& Q6 k/ S' m& q
2 H# G- W1 `) W$ F' n因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
4 p5 b3 v" {3 g1 Y
所以發展出一種特殊的命令叫做正規表示式
0 R" U/ J- c7 j# J4 m8 N5 q- X
我們可以很簡單的用 "s/
$ W0 l5 x  R# }4 c, Q# Y因此jdk1.4提供了一組正規表示式的package供大家使用

2 S5 ^  l2 |8 L& A2 }若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

. N7 d; P( K! Q* R( i  g剛剛列出的一串符號" s/
( f/ a- f- z5 @2 T" L* D適用於j2sdk1.4的正規語法

"." 代表任何字元
6 `4 m0 i' F, R/ y
; E1 d* |1 y- ?, T. T正規式 原字串 符合之字串
. ab a
.. abc ab

4 t/ \/ [; E2 K1 y0 z6 c3 Q"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
) F3 ~: r4 D, u' S* A
正規式 原字串 符合之字串
. d6 ?6 c# ]2 M+ ab ab
* abc abc
: a7 s" m1 G' H( b) Z  }" M8 x4 U
! F; D- {: U; {6 B"( )"群組
* U' e9 d# \# C
, a' v0 f( P; `5 m' p# {正規式 原字串 符合之字串
4 x$ b' p8 j. d' t' ^; @3 i* t(ab)* aabab abab

字元類

正規式 原字串 符合之字串
0 Z, D6 {- ]& f7 U[a-dA-D0-9]* abczA0 abcA0
9 M' n& n& Y" E/ A0 t[^a-d]* abe0 e0
[a-d]* abcdefgh abab


簡式

6 @% y2 I! V# x+ m7 d' E! @, b\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
3 T1 m5 Q% R& f  i\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
. M/ Y; g7 I, I
; ~1 D. X3 V0 J$ j6 z5 h& W! z每一行的開頭或結尾

^ 表示每行的開頭
$ 表示每行的結尾

# B6 T# m* c$ M0 J% S1 E--------------------------------------------------------------------------------

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

/ {4 T  J0 k1 d- ]! y+ p& WPattern—正規表示式的類別
/ C; e- B- B! o( VMatcher—經過正規化的結果
! r1 Z. v; B+ oPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
1 m. J5 |# ?" J
; E" e8 n8 ?& D/ E' a  V範例1: 將字串中所有符合"<"的字元取代成"lt;"
! i8 f) `" K+ a; Y9 Z, F: m1 e: Y
, K& N4 s1 N* h$ b. ^$ jimport java.io.*;
3 P" \& v0 e7 g. H' x- U% J  wimport java.util.regex.*;
/**
+ V1 Q% o5 d8 p$ a1 U+ l* 將字串中所有符合"<"的字元取代成"lt;"
*/
; }, t8 H/ f/ ^# v# r! }5 wpublic static void replace01(){
' [1 [7 K4 `2 [/ m5 \. w// BufferedReader lets us read line-by-line
  v- V- x6 p- n5 I* PReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
; _( s4 ^: k' A2 z; f2 p$ ]Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
: o7 B( a2 n( M  q2 s' ktry{
while (true) {
String line = br.readLine();
6 c; h, j0 a; y// Null line means input is exhausted
5 u8 \+ S6 y0 oif (line==null)
break;
Matcher a = pattern.matcher(line);
7 P: u- [  p# M4 bwhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
9 G" [* S1 T& |$ ^! |) n}
$ g! V- A! X% r. q, Q5 g3 rSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
: b3 j2 _8 J- D% @- ~0 K+ H7 q, `}catch(Exception ex){ex.printStackTrace();};
% _1 D' u, v+ J. P: B- z+ `1 S}
0 x6 I. k5 \  F, f$ E
' Y# P0 u6 [: n  k$ {  i+ X+ R範例2:
# r6 P; y5 A5 u, ]
import java.io.*;
5 P- S, _6 Y2 Fimport java.util.regex.*;
7 H, k3 H% ^$ V3 f4 N1 {/**
& R  K: C+ U! i& r: X" J! s. o* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
: T* D8 f' K0 d( @// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
. V5 y+ C$ ?2 U% i! z6 A9 uBufferedReader br = new BufferedReader( r );
+ v- G  z' Q! f$ }" lPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
( P" M# I  |5 c) B+ otry{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
- d  r4 y  a) L1 x% g// Null line means input is exhausted
  d* ~$ ?7 t4 Pif (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) {
$ N: C) S' g" o* wlongest = i;
" w1 }4 D5 o" K2 ~! f: h" wlongestLength = words.length();
% R/ m( A+ ?! R  p' \; _* l  E}
}
' I& K9 c. C) E% F6 lSystem.out.println( "長度最長為:" + words[longest] );
}
+ _5 v' q4 D1 [! J}catch(Exception ex){ex.printStackTrace();};
}
; }: a0 `9 b+ Z% u+ r% A3 w- }
--------------------------------------------------------------------------------
5 {" {7 f5 ^0 z& {2 O5 O- h4 ^. H
( C9 h! ~* }+ c! Q( u# k1 F: U- T其他的正規語法

/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水