查看: 796|回复: 1

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

Longe

管理员

论坛测试[砖]家

Rank: 12

金币: 7319
贡献: 615
威望: 9151
最后登录: 2026-10-4
帖子: 1876
积分: 25897
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);
* s( {' M% v6 e7 q. Z* R, ~! a7 R5 a}
5 X9 J# A- l+ }0 N  ?9 W" d}
4 e+ b/ b6 p/ c$ J' z; ]7 P7 ]& \* n3 J! z" C& C
Matcher类 4 u5 u) G; o' p8 M1 r* ?3 D
: B4 i+ H" _3 y5 f1 p! U
Matcher类的实例用于根据给定的字符串序列模式，对字符序列进行匹配。使用CharSequence接口把输入提供给匹配器，以便支持来自多种多样输入源的字符的匹配。
% p0 f) r) V; h
2 @0 G! j+ o/ p& h通过调用某个模式的matcher方法，从这个模式生成匹配器。匹配器创建之后，就可以用它来执行三类不同的匹配操作：7 R; d2 W% t* S! w: d1 s6 e+ l, u* x
7 O6 J* Y8 [5 ]+ k9 k
matches方法试图根据此模式，对整个输入序列进行匹配。 * h6 d# J5 o9 h5 J$ e
lookingAt方法试图根据此模式，从开始处对输入序列进行匹配。   t2 ~; E/ a' T' h
find方法将扫描输入序列，寻找下一个与模式匹配的地方。 3 C6 f1 C- Q0 P
& O3 M$ B' p& ]
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询匹配器的状态，可以获得更多的信息1 e- o5 }6 w) A  L

" h& x6 O/ d  x( \" d这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需要的话，可以从匹配结果推算得出。& \8 @( ?; ]$ p7 j
) ^& G4 s6 c& f; L
appendReplacement方法先添加字符串中从当前位置到下一个匹配位置之间的所有字符，然后添加替换值。appendTail添加的是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
- m5 H7 {+ L# ]8 d* r' L. A# F4 O
6 e6 e4 p. J  _' D例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例简单的单词替换。6 y( l$ u. i2 l. v% k

/ ~: b& U8 M* G" E! ZCharSequence接口
: ^1 A9 r" E4 d: n* h5 y1 s, ^' K+ p# ?  l& h
CharSequence接口为许多不同类型的字符序列提供了统一的只读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可以通过实现CharSequence接口，编写你自己的输入源。$ _0 e* H' I7 S! Z* c6 g9 C- _! L
9 z- K- S  F3 _1 {
Regex情景范例
6 v+ f; _) X( M( i9 P
* m" x" i4 G: S$ Y! ?8 A以下代码范例演示了java.util.regex软件包在各种常见情形下的用法：4 O: n5 A+ y; C' O9 Q+ v
- T! K  E) P8 u" l7 P1 p
简单的单词替换
6 Y8 l; \+ ~( l, z8 b' f. K, P9 N& V5 n1 P
/*3 k4 C7 y* y! o1 E
* This code writes "One dog, two dogs in the yard."
+ x3 W  }# X' V! J% D4 u; {* to the standard-output stream:
* G( I8 i: P. J( D# @& v! H*/. F" l9 t+ ^1 q: l9 n
import java.util.regex.*;
: u1 m8 b& i$ H7 l, N  u7 l' `/ {! A0 w# E
public class Replacement {
5 X1 E3 b% A$ n6 s9 }- kpublic static void main(String[] args)
& ?- q" R) i+ D7 c  B6 A    throws Exception {
0 q: Y- U8 _& w# Y// Create a pattern to match cat* ?& Q: m& _; s  I1 ~5 L
Pattern p = Pattern.compile("cat");
/ W  w" M. a! B) \1 @4 Q  L- z4 h// Create a matcher with an input string1 |$ q* t- y1 o) \
Matcher m = p.matcher("one cat," +; G+ ~+ |( c( l2 i( k
   " two cats in the yard");
' ]5 P5 H0 l2 E9 z, W0 aStringBuffer sb = new StringBuffer();
" R6 ?! F7 R2 K& I: r8 Dboolean result = m.find();
! @7 v9 s" g4 H// Loop through and create a new String
: b; Z' {; x9 d+ c& |8 L- j6 p7 `% [// with the replacements: z1 R* ^# G" w3 z3 H4 f& |0 n4 R
while(result) {
9 A* Q# J9 O# [8 em.appendReplacement(sb, "dog");0 I4 z& ]$ u$ D+ b7 f4 o9 z' d7 X3 u
result = m.find();0 F& K% ^) f  x* v, G3 u
}( m1 x/ e! f& z5 V6 ~( ]. Y+ v
// Add the last segment of input to 1 @- j7 ~0 g, O  E
// the new String
1 M5 r, k7 n) J/ T4 \4 Tm.appendTail(sb);8 A  z0 _2 ^3 n. E# r# Q
System.out.println(sb.toString());1 f" o% b) E+ I, X. W, J
}
& D( H5 k1 A3 P9 T}' _8 W3 k0 N1 i0 e4 h* }

/ u, m: Z! u8 X- O( Q电子邮件确认) J* I* j- z  \8 g# R: o
0 O! s3 f. N! ?- I4 C. k
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在需要时加上它。
. F/ v- J- R1 S
+ w% i( M1 X) {+ x/*0 U& ~+ D& e7 T" Z! g7 Z
* Checks for invalid characters5 v9 M* w' d& u
* in email addresses' R0 N) R" L* R* J
*/$ Y1 ^- w% j) {+ h: Q7 W
public class EmailValidation {  b  @8 G- b& a$ M) O- L
public static void main(String[] args)
0 e0 p* L2 y1 M          throws Exception {
) |. {1 h/ \% x# N7 ]* C
4 K7 K1 `( u+ E& S( v5 g0 _6 dString input = "@sun.com";) J2 }7 ?  r; Y/ H( T
//Checks for email addresses starting with7 o& ]: b& x( E  W( {# G9 F
//inappropriate symbols like dots or @ signs.
/ J. j2 u. ?8 _# DPattern p = Pattern.compile("^\\.|^\\@");
5 c' E2 X/ ]9 X' GMatcher m = p.matcher(input);% M$ p! [% U1 E1 b! [' V! T! O' n
if (m.find())
0 p1 v: j0 q- e! J2 E1 d. {System.err.println("Email addresses don't start" +: ?! n' h  D# e
      " with dots or @ signs.");
) N* w0 G: Y4 a//Checks for email addresses that start with
& ^$ K. k$ D+ V3 ~* }//www. and prints a message if it does.
& I) |4 z( n! Q" F- V+ t& B! Op = Pattern.compile("^www\\.");
" U6 g% S, q9 I( Q: e3 Pm = p.matcher(input);7 ~/ L1 M0 O" s! u
if (m.find()) {' O* ?1 H; S+ \* m
System.out.println("Email addresses don't start" +( m! W4 \' K/ s# d
" with \"www.\", only web pages do.");( w" L2 D5 J  L0 {" Z% ]6 r
}
0 G4 h2 s- }& b* r  U4 bp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");' n+ j" ?. c1 e) b5 ^7 U
m = p.matcher(input);
0 S$ o" P9 P% z) x, H! w  `5 t$ k' ?StringBuffer sb = new StringBuffer();
( a- }" R% d  H, |3 n( zboolean result = m.find();* ]. h- T0 Y, J6 x; V/ K
boolean deletedIllegalChars = false;( t' ~1 Y7 o% s. [
- g5 D  [9 y# S% N
while(result) {3 \! c! w7 a3 w
deletedIllegalChars = true;
, t; g1 k8 ]( f4 U( Ym.appendReplacement(sb, "");
  z% c4 I: m, ~) {result = m.find();
+ L& P6 W* l' N/ p}
, U2 `; H2 h# c* |, }& g3 f# Z/ L- Y! M0 p/ ?9 n; i) J1 m
// Add the last segment of input to the new String* y: m: M1 K. E- S# G
m.appendTail(sb);
  d$ |+ q0 r$ g  V, L5 P' L& n( Y$ ?# v
input = sb.toString();- f/ w9 z/ D4 t3 {! y2 O1 |

$ |- @# u3 ^9 b; a7 Wif (deletedIllegalChars) {
8 C) C8 u& F8 M) e6 S' i0 ?System.out.println("It contained incorrect characters" +
9 b+ ?9 L! Y% S6 l/ U- |    " , such as spaces or commas.");% w2 w, C# u7 l
}
  d6 g6 K: K  G}9 o6 o0 s* f8 p0 b7 x1 s
}* t4 J6 X5 {2 a# y" T6 q

5 h! `) Q  j! H8 m( g从文件中删除控制字符/ a+ `8 r/ G# ^3 f! e

8 h1 A$ Y2 f8 X- p, P/* This class removes control characters from a named
* I# o1 p! X. w! Z* [8 b3 Q. K* file.  n6 H9 M5 v- l: k+ }. I" y& v
*/
& Y& E7 k2 c% T" b. Himport java.util.regex.*;! h7 [4 x$ w, ]/ ^: i, I! H
import java.io.*;1 ], N$ p5 \1 I; q+ C' q# {8 ~! g
' `" L! u/ \- }* f! l3 t
public class Control {
( G4 A0 \5 [/ K) f. cpublic static void main(String[] args) : O8 t, }  J. Q8 ^# o. c
         throws Exception {+ ]$ Q; A; U  L( R1 T" R: k# I7 }

+ Y" \; t3 L5 |- d% e. W1 H1 ^; _7 ]//Create a file object with the file name
5 J7 q% C/ @3 N, N/ k# ^//in the argument:/ Y2 d" N9 N- W/ I1 i
File fin = new File("fileName1");5 f" ]/ I$ I- Q# M
File fout = new File("fileName2");: y/ R3 e' x7 W9 a
//Open and input and output stream
% C) X$ W. ]* `) D, ^FileInputStream fis = , j% x" ~% U! L3 o
   new FileInputStream(fin);) P" H4 ?4 F( \3 o( v$ a1 g7 Y# V
FileOutputStream fos = $ f$ ]9 ], L& k1 O% z+ E
   new FileOutputStream(fout);
6 C: Z3 L& T- E1 K' R
3 `! S" Q. q/ x" ^BufferedReader in = new BufferedReader(
* s; ]0 L9 B8 r( [    new InputStreamReader(fis));' |: [& o, t$ w4 [- V2 s/ G
BufferedWriter out = new BufferedWriter(5 o% p! g1 I. j
   new OutputStreamWriter(fos));
+ L, W6 I2 w+ V2 {% u1 G+ V) z' T+ \. C' z
// The pattern matches control characters- |( I, {% @. l; g5 X! e. t
Pattern p = Pattern.compile("{cntrl}");
5 z2 K* Z8 G7 _6 I1 iMatcher m = p.matcher("");6 B" U' O, S  C, P+ t" U: e2 z" B
String aLine = null;5 A. b/ b" S9 E7 v  D" P4 |% a  L
while((aLine = in.readLine()) != null) {6 k" ]/ K6 c- E$ C& K& h
m.reset(aLine);8 B/ D& I. o/ D; U; h8 s  E
//Replaces control characters with an empty
2 j  x% ?4 i" k7 Q//string.) i: p" m- p3 f7 B3 _' R$ t. |. g$ y
String result = m.replaceAll("");+ A* v: R+ o8 C9 B
out.write(result);' T! I4 m* y+ E! w2 o, i5 W* e
out.newLine();' J4 W; I% W+ v- d- ?- _
}7 O0 l, ^3 L2 a. |1 _7 H+ I. F1 M
in.close();7 l* V6 U( a$ W4 a7 j) i( k4 ]
out.close();
, g9 L4 R2 U$ j}
# q4 p6 [% t  l( v! R9 h}' c# q5 l6 W- |4 |9 w9 U* T( B
% L: M2 T/ y* O% }# V
文件查找
: D, S2 \. h# S9 C$ e7 P- ^- r5 @( m! Y
/*
: f2 A/ x# J0 w+ h: T* Prints out the comments found in a .java file.
/ f4 c- {7 J  k; A4 e*/
* v* h. Y+ m. E8 ?9 o8 y( B( }- gimport java.util.regex.*;
- w6 A( K5 J9 G! E9 w, Yimport java.io.*;; d; ?8 f- \8 l2 A" X8 E
import java.nio.*;# h" j3 K. @  Y( U/ |" O  N
import java.nio.charset.*;
4 u9 D6 ]* D, n5 U3 g! r6 jimport java.nio.channels.*;
. }& R5 R1 C6 x, s" R& T. o
1 s0 p! e6 q' L) V/ }) opublic class CharBufferExample {
2 d; J) p" ]' N! l7 Tpublic static void main(String[] args) throws Exception {2 V& G9 S: w/ ]
// Create a pattern to match comments3 `: z  K  x7 Y# ~
Pattern p = 6 ?4 n" K8 S" L9 s" x- `, W
Pattern.compile("//.*$", Pattern.MULTILINE);- d% h- S" L: X1 N2 Y

2 W- s+ h" Q; G* D' u. w// Get a Channel for the source file
, S; P6 F1 ]  mFile f = new File("Replacement.java");, k& L+ K, Z1 c% n, `) M
FileInputStream fis = new FileInputStream(f);
' h1 c8 U) l5 k0 d7 D, dFileChannel fc = fis.getChannel();
; I' {+ @, z) g' O+ h, c$ }) J! n3 t0 Q9 f& u0 w; P8 J. ?
// Get a CharBuffer from the source file5 ~( X; G/ ?* s* l
ByteBuffer bb = " z% C7 T% O( ?6 M' U0 g
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
4 Y" N, b9 e4 l8 o! ^  OCharset cs = Charset.forName("8859_1");5 d7 B, g* y5 m, a6 Z, p
CharsetDecoder cd = cs.newDecoder();
% W; c* L: s& OCharBuffer cb = cd.decode(bb);
" e: j' K) e1 M- L3 g+ H8 o" i. {% J3 V. |
// Run some matches
7 Q* V" a1 F, _2 n# ~Matcher m = p.matcher(cb);
" l+ {: u7 E; Cwhile (m.find())
3 e1 z) t+ Y6 \3 E9 ?# e4 N$ ?  r- eSystem.out.println("Found comment: "+m.group());, |& y2 R9 j% f- R- Q- }
}2 p( ]" e2 M6 F% m$ p  i3 p( k
}
! m, g0 F0 d* T+ W* ]+ X8 r1 d6 G
1 [1 S3 `3 }% p结论
2 A$ [0 Y$ ]( H+ X% Z: A现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之，在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
1 V8 q. k/ e4 `
, X' [& g" T5 S1 m9 B$ F& QJDK1.4之正規表示式9 U& P$ m  J! m  \
written by william chen(06/19/2002)
* n/ W! b2 e, ]# ^# A% J: Q  Y8 e" c! Q3 z" J; p6 V
--------------------------------------------------------------------------------  A" G' x8 b2 T$ @* G& n: Y4 w
* i6 W  m3 q+ B& f
什麼是正規表示式呢(Reqular Expressions)
! I5 l8 V) a5 e6 j8 t  k$ C) p+ X; I1 u2 {; J
就是針對檔案、字串，透過一種很特別的表示式來作search與replace/ @8 N5 A/ A& @, ^( U8 m* y7 u# g- q

& L6 d; F; ^/ r' {因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
8 w; b5 c. p, ]2 i
6 {3 C7 G' {: [. }! B: u所以發展出一種特殊的命令叫做正規表示式
% o5 {) x5 b9 B% n& C6 D/ Q  Q9 u  r2 e' y4 a  Z/ r
我們可以很簡單的用 "s/2 b, i- M1 I% n6 Y4 d! T$ m! T  Y
因此jdk1.4提供了一組正規表示式的package供大家使用8 O% [5 n. h( }) s5 g
+ c0 |1 j) f% E# y: j
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
( Y! A2 x9 w5 R! C, X2 F
7 E+ r, i6 Y8 b剛剛列出的一串符號" s/
7 S% S  y% N( F3 l# J- V1 t適用於j2sdk1.4的正規語法
6 N% B: Q+ ]6 s# x6 q) ]/ N1 k  r, j* ^5 ~( y/ W# y" r
"." 代表任何字元4 ~, T& G4 Z- ]$ x9 z5 ^
. ~+ j3 `  h+ ^, o5 d$ B
正規式原字串符合之字串
5 l3 R1 r! V0 ~4 K4 H. ab a 1 {; P$ H( @& t. g* l* Q% }( R/ I
.. abc ab % H+ B1 i$ T, f, Z2 I! }, P

# S, J" g, J  q$ Y3 P"+" 代表一個或以個以上的字元! E2 @4 C" Y( M5 Z0 W# m) d* s
"*" 代表零個或是零個以上的字元
# f7 D9 l& O& O" {4 T/ |* c: C# z  A& ^0 b+ g, P) B' }0 @
正規式原字串符合之字串
3 T8 n6 H* G- C; O( l# T" B4 F+ ab ab
& x8 v5 C' m' T4 ~* abc abc 2 K4 f8 }* b8 R0 Y5 A7 l3 Q' z

* s- _' X9 a# m5 u' n"( )"群組
3 i' H: U- D5 C
7 I+ C+ g' Q3 s! ]正規式原字串符合之字串
" y$ o2 _9 n* C, D, v(ab)* aabab abab
7 }7 y0 x% C& o2 A2 B1 e+ k7 y! j) w" C' ~) v3 s, b6 U
字元類
5 V4 \) z/ [: {/ D/ L2 l3 V7 V2 l& ]" @6 T
正規式原字串符合之字串 % E$ H$ ?. P$ I0 `6 L8 ^- m( p
[a-dA-D0-9]* abczA0 abcA0 / b* \  O8 w. F) L
[^a-d]* abe0 e0 . ~2 w3 F6 r4 U( {
[a-d]* abcdefgh abab 2 o% {: J8 ]# J$ O

  ^7 C* T2 j/ e  G6 }) G
/ k6 ?. A* H( _. x& x& X簡式* e- S3 [$ k7 ^: c& f6 v# K
8 p  ]6 z$ A( s+ A
\d 等於 [0-9] 數字 ; c8 x( h$ e  s
\D 等於 [^0-9] 非數字
' u2 h, L( e/ K/ a\s 等於 [ \t\n\x0B\f\r] 空白字元 $ U: a) n% A  D( b
\S 等於 [^ \t\n\x0B\f\r] 非空白字元 4 V- n! |, Y3 M# z. W3 f! P2 N. L# O
\w 等於 [a-zA-Z_0-9] 數字或是英文字 / R% B% x- f- D
\W 等於 [^a-zA-Z_0-9] 非數字與英文字 * p7 J2 P; s7 y  h+ ]8 }1 d4 e

& g- y( u* E  ]9 u* Q& q每一行的開頭或結尾
/ d4 I8 `3 P+ B: b( v2 ^2 k8 F% J. I; F  R9 h
^ 表示每行的開頭
9 g3 L5 a3 @- _/ m6 i" n: {9 K8 I$ 表示每行的結尾) ~# k0 {$ o( D3 g# j. p1 m
# B* N* F, P! P, Y  b
--------------------------------------------------------------------------------& [: [; ~  e; S2 d# Z

$ }3 u4 y6 U" x5 o正規表示式 java.util.regex 相關的類別 ( \  }# A4 n2 o- W
/ d" c& R$ V5 w
Pattern—正規表示式的類別
. Q( v. v0 \/ Q7 ?9 a" d" N- j9 j0 ]Matcher—經過正規化的結果
7 ^3 `8 g+ I: ]6 t; E7 gPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression6 h; J9 O9 U, i9 P
' h3 k2 k& q$ x- K$ E2 f3 {7 Q
範例1: 將字串中所有符合"<"的字元取代成"lt;"
+ e3 K' r7 d# l( o/ y+ ~7 G7 k$ z+ @" w# f
import java.io.*;
0 p* p! x* w5 b& z! Bimport java.util.regex.*;5 a# V/ p( C. r, M: t" C7 u
/**
; _* ~! x; [. {# u$ a+ k5 @* 將字串中所有符合"<"的字元取代成"lt;"7 r# _0 {9 I0 a
*/. S- h" J3 ?2 f( |
public static void replace01(){
1 C; k) x7 u# ~! d// BufferedReader lets us read line-by-line7 Z( d$ `( \, \/ E5 ^# t4 h
Reader r = new InputStreamReader( System.in );
" v0 B- m# N; s. N7 s9 s. N% ]BufferedReader br = new BufferedReader( r );
( N* [* v# d, \  {9 RPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元- z6 N) e. |2 a- c
try{& Y, M& y! @* o: d$ C/ A: _( K
while (true) {6 \2 u% b; `; [5 M
String line = br.readLine();
% P/ d$ l  }) s' ]# U, }: Z4 i0 g// Null line means input is exhausted
+ d: _8 F( Q* S/ V& ]if (line==null)
: B6 z* f" K2 k8 Kbreak;
+ l( Q$ d" f# {! [Matcher a = pattern.matcher(line);7 _: \! Z& s8 r5 c4 o
while(a.find()){
0 Y, Z3 f2 H# SSystem.out.println("搜尋到的字元是" + a.group());" q) ^. v- E, J5 v2 w/ O! M/ ~
}
+ R; Y1 F$ ~' {9 n) HSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
, K7 B# C2 i" `; W$ m) m+ e6 X}
& ?# {6 \- w6 B# l8 R0 E# `3 Z}catch(Exception ex){ex.printStackTrace();};0 E3 E* ?& k! F9 K' }
}& t' {' O& z: E$ Q) h" I$ n

7 S& e3 v; ]4 l範例2: : E4 W$ h$ \8 z, c2 G
, r; X# p' U, Q8 `4 A1 d  L: ~
import java.io.*;
0 }7 y, v/ ?6 x! c' bimport java.util.regex.*;  n7 _1 E3 Q4 n; d" L
/**( [# o  y- n7 l& x1 I
* 類似StringTokenizer的功能3 l9 @* @, G; r/ e& }9 M6 t1 {" D
* 將字串以","分隔然後比對哪個token最長) c. u6 R8 X  f# W. g3 E) x
*/
9 x4 Q  G8 k* y" |; [7 qpublic static void search01(){% o% U9 ~! G7 N6 F: ]
// BufferedReader lets us read line-by-line; V1 [/ u- ]" n3 x
Reader r = new InputStreamReader( System.in );1 \6 W6 U/ {' \. T
BufferedReader br = new BufferedReader( r );. T% h6 \9 `! q1 p: S
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
' ^. S# h' ]0 m9 ~; ?, Gtry{
- b; r! P/ }5 p- I2 E; O# {while (true) {
4 H/ m+ V: z* g7 Q3 MString line = br.readLine();
. N& p8 c0 I* }+ AString words[] = pattern.split(line);
4 L% F6 Q8 q/ G& ?% n  e' B' |// Null line means input is exhausted9 g( J  ?+ w8 t3 b; M
if (line==null)0 d! F1 h, `1 i1 P# K- V
break;
! X3 ]+ X; j& p! j1 i6 D// -1 means we haven't found a word yet9 Z' t* ]( H, ?( I* o
int longest=-1;3 D6 i- m1 v4 u; i
int longestLength=0;
2 e8 i0 L5 p; Z* v/ g$ }for (int i=0; iSystem.out.println("分段:" + words );( i* S: W& }# f
if (words.length() > longestLength) {
0 J9 P( C% b9 }! V1 y, Jlongest = i;- k# N7 a+ [" n
longestLength = words.length();
5 U) T7 z, Y* v$ T}
& `$ g- ^; s, t4 U1 b% @" [}- I, {$ _/ l1 [" y
System.out.println( "長度最長為:" + words[longest] );
  b' n; |  q$ X# a' s}: Q, }) p, Z- ~  Z/ W# ^& G
}catch(Exception ex){ex.printStackTrace();};
# I0 p1 N9 q  F/ r9 ^( l5 n8 v}& w; B. A. ~8 ~2 a3 b
4 I+ F: r' [5 |2 |
--------------------------------------------------------------------------------
' W9 P! x  ?- L8 A# l. m( n+ t
$ J0 c2 ?; z# b: L其他的正規語法
! e# d( A# `4 U2 Y  Z, |" P, s1 ]5 X4 y* n
/^\s* # 忽略每行開始的空白字元
4 L: B6 ~$ r1 g! Z4 c9 i(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)