关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
. Q/ g5 e  e# J/ f! y0 m0 X
0 P2 S/ \7 W, A4 Y: N' o0 v7 T3 m& z支持多种平台

! w. v& z# g2 k0 r) l
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
* o7 H! F3 S  u8 |! f
/ C1 X5 J2 f. s$ x$ q正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
7 E, J1 p/ |' A% X( [
- y" y0 Y5 L& X6 a9 P8 D! D9 j许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

* \" ]5 ]) }! k7 i/ [8 a比你想象的还要普通
' V. N9 B7 Q- c! }6 t5 D; t" n1 z随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

正则表达式101
6 e0 E  d4 l/ x2 l+ b# A很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
0 D. {( E( Q- U2 a* o: h2 u+ x
3 N4 A( q7 Q6 z1 i4 L第二部分：
: j; v' x) h9 Z% o' n; C2 y0 e----------------------
字符匹配

2 `  r# ~$ t/ K  J# N3 n# n正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
/ K! P6 l% Z( W; \$ j9 Q0 V
* F' T& \  M- d* r- c每一个表达式都包含需要查找的指令，如表A所示。

$ _  s6 t9 i3 CTable A: Character-matching regular expressions
格式说明：
---------------
操作：
解释：
  `6 ^1 b6 v2 p/ _0 K例子：
结果：
! s+ u0 j! |6 p. m) u----------------
.
Match any one character
( e. u) I5 c  k9 `grep .ord sample.txt
1 D" @7 ~- L' T4 GWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
9 G7 ?0 `! t5 {8 T0 vMatch any one character listed between the brackets
6 b; X9 p. k* d, E. Q3 f7 jgrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
[^ ]
- [0 p7 q4 g0 @& S$ pMatch any one character not listed between the brackets

7 \) e. V7 o+ N3 z* n# r5 ?# T7 b9 Hgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
5 s7 n% d9 ?) A6 ?+ s& \3 f
grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
! Y, j  J: W' T: K/ z. h
1 \( {6 \0 e* S5 K! xgrep [^0-9]ord sample.txt
$ @* w  C# P9 [; S: gWill match “Aord”, “aord”, etc. but not “2ord”, etc.
* n6 |' V3 w7 ~6 f! V
' U* }) E' m  H6 y重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
9 Y, u5 G- C, }
6 I. }) W! S* U9 E  l0 qTable B: Regular expression repetition operators
格式说明：
6 C) u8 n! {0 G; Z6 U' ?+ e---------------
0 K3 x6 j* F6 Y操作：
解释：
例子：
' H* q# c  U  c' N) f* k7 N0 V) G结果：
----------------
; v4 U, C( C. k) n0 Z?
6 m4 C* a$ i( H# RMatch any character one time, if it exists
egrep “?erd” sample.txt
* i& n) E0 l8 X/ y; R% z# t  T' JWill match “berd”, “herd”, etc. and “erd”
$ j0 i+ ^4 k4 M------------------
*
( ~( K* r2 M$ U3 ~, \8 \Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
5 U" w1 Y2 ]4 P% @. ^7 r-------------------
- T0 o! P9 \$ x1 x: |+
Match declared element one or more times
8 f+ e% C- {4 Q& ~. |egrep “[n]+erd” sample.txt
- I# ^3 |. t: o2 S) T( U$ {3 o6 R# ^Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
/ n& Q/ T2 Q+ ^9 w{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.
( ^5 F3 K2 ^( c. g) f" y) ?------------------------
{n,}
Match declared element at least n times
8 @0 }# d2 K. x6 j  B7 V2 W3 ?8 {egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
1 D0 }/ @5 r- q& s6 y------------------------
; j. q1 m6 g% P& D/ `{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
' G. N# s1 s" R- dWill match “nerd” and “neerd”
' M& F7 N. `. _8 Y4 f
第三部分：
3 x, v9 U3 N4 h- B----------------
' V% Y2 E8 _/ E8 ~' x2 r5 q锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
* g, \% a9 A: k( [3 I0 G  @7 y
s/pattern_to_match/pattern_to_substitute/
1 n+ v; s# S8 K% b" q
: b8 `7 `4 Y2 U! D* r/ a5 ?
Table C: Regular expression anchors
-------------
操作
解释
例子
结果
2 @, `& D+ h# q4 v  H6 d---------------
^
& ]/ v* `. Y; G1 E' b2 qMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
, d% _' k2 Z5 D7 Z. M/ c$
Match at the end of a line
, C4 U5 k, n5 l1 ws/$/ blah/
Inserts “ blah” at the end of the line
! L0 f0 e  ^  i6 o+ y* y: |0 h---------------
\<
& A1 d! |) v% L% ?8 NMatch at the beginning of a word
! J- O2 G' h! |# Ns/\Inserts “blah” at the beginning of the word
9 |5 b9 J- B% i- o2 t% l, {, z
4 n; \  W$ ?( x1 A/ Wegrep “\Matches “blahfield”, etc.
------------------
3 k. X1 H1 l) K+ |4 }\>
, k" H  K% q1 @: z9 a2 q. m( s" v$ ?, \Match at the end of a word
! q: m6 u* |9 X/ X+ _/ [s/\>/blah/
3 Z8 [$ B3 b1 K9 a7 mInserts “blah” at the end of the word

6 \8 |+ M# E( |egrep “\>blah” sample.txt
' S$ A! z( ]! ]; b) @5 O  bMatches “soupblah”, etc.
---------------
\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
/ \" z+ D4 h! U5 w7 p" yMatches “blahcake” and “countblah”
  i- Y% S5 L5 W, y5 J! A-----------------
\B
Match in the middle of a word
8 D6 `$ B6 N% o2 _( _8 Q, Eegrep “\Bblah” sample.txt
Matches “sublahper”, etc.
1 H& O. W9 H- b" A
6 F) \2 @, z4 h: \: Z& I0 p8 i间隔
$ A, N) K4 W( U. J/ F' w6 G
- g. s9 H0 B. Z- b# M5 XRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
6 M8 h+ w5 b- ^4 t
4 d3 ]$ J' @% @5 Jegrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
3 k$ _& |1 L0 k5 d, ]  z
# i8 @3 [) m/ S8 i; V9 I* vegrep “[nm]erd” sample.txt
$ g# X- E$ i# ^! K1 N+ ^
5 H& E0 c) r$ O8 n) W: U% C当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
----------------
% E% v5 h$ x2 n: m一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
" G& }, Q: u1 G4 Z( (left parenthesis)
) (right parenthesis)
| (pipe)
& a% @! T; W% f. k* (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)
; r' }" Y1 w! E* q2 d6 G0 v
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

  I. P, [# {9 h) C+ g. _总结
* D- s1 E. Q# i# `/ K+ X在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
& G3 i% r4 H. ?) R----------------------------------------
3 _/ L+ T/ z5 S* E正则表达式和Java编程语言
* X7 j& e% h+ B# c8 z( I-----------------------------------------
类和方法
, l* E) G& y# f
下面的类根据正则表达式指定的模式，与字符序列进行匹配。
& }- D1 I) U& D5 [6 _( a
Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

6 Q% |; `+ j. n' m) E# j4 ~split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

- S6 N" w' r# u8 q8 b- _/*
. q3 b2 w& m' o1 {: s* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
  }. R6 f+ y; I/ ~+ {1 L7 B: Aimport java.util.regex.*;
8 Z5 X( g+ z5 c: a  S: O1 J" }
$ r+ c3 |2 C' l$ apublic class Splitter {
; k3 |" m, o' r! Fpublic static void main(String[] args) throws Exception {
5 `. k% [; H8 x& |// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
& n8 d/ D. v4 e# |1 e// Split input with the pattern
2 O/ K" y  v' M: G$ dString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
+ p1 |# c2 k9 b9 n# D$ V}
}
- x) C: m* }! X: @
Matcher类
) y- j5 O# G/ G' a
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
. m4 K7 y; t; I& S
, t3 v, w' J' B0 z. I% M5 W通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
5 w! c$ B' o. U4 S2 ~0 W' K
matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
3 e" k6 f( {: W7 K- [  ?find方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
% }/ m+ U9 A1 u# R" E* M# u
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
! U$ p( V! N) |6 K" H* Z4 j
CharSequence接口
8 R5 d! k+ V, A) U) J
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

Regex情景范例

( B* U0 |* V7 K; j- y以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
: x' x( ^8 `& o1 A. r, F# i/ ^
简单的单词替换

/*
- ]) D0 M2 f$ b" c; G/ c* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
' I- E" K/ O5 F7 h, I  R" u*/
import java.util.regex.*;

1 L5 F9 ?; \, Y" X3 h5 I) @public class Replacement {
0 L( X( b) E6 h4 N! e# npublic static void main(String[] args)
4 Y! m0 }0 O& }  F. g3 f3 t7 Z       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
+ p) D$ ]# s7 }+ B5 Q1 ~' K// Create a matcher with an input string
4 |/ C% X  r' g! U4 [3 zMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
0 \5 V; d( w% p+ {// with the replacements
) U9 j' f* ~2 Nwhile(result) {
6 ~; I6 R7 I3 B7 xm.appendReplacement(sb, "dog");
; g3 y0 f" L/ g' _6 |- \3 fresult = m.find();
}
1 v/ Z+ x2 m: J- [// Add the last segment of input to
// the new String
0 b( y' |, F$ w7 C7 xm.appendTail(sb);
% e! P! c* T* h+ a3 OSystem.out.println(sb.toString());
4 o' M6 y' U2 V3 G: j  H2 k}
}
$ K( ?1 a0 B. g1 a
* m0 P' O4 W' y" A; \- X# X% |. q7 n+ r电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
) n' P9 C1 r/ D! o7 y" K* Checks for invalid characters
/ i0 M$ B' X# [4 ^$ j% U6 J* in email addresses
& X7 W3 z$ Q8 D*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
$ K- W7 h! X1 Z7 _0 ~8 m           
) Y+ v, ^( Y& ]String input = "@sun.com";
//Checks for email addresses starting with
" x* i/ \" u( j- E//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
; o9 X7 d8 V. e0 H0 R6 A8 X' A5 PMatcher m = p.matcher(input);
& |: V" t' [  H; n1 f; D* ^, X4 Jif (m.find())
System.err.println("Email addresses don't start" +
7 I6 W2 }+ r: f" F( I0 u         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
4 K9 O! d$ ^8 W& I! M! Tm = p.matcher(input);
8 P* j) T" r4 F6 i' F( E- wStringBuffer sb = new StringBuffer();
boolean result = m.find();
; U, a* \( k8 k! J4 x! a7 l2 I# H# bboolean deletedIllegalChars = false;
, z! `) ^4 G/ p$ z- n2 y  d; J
, o* C2 a5 u6 zwhile(result) {
deletedIllegalChars = true;
( q1 I# j" c2 W, Vm.appendReplacement(sb, "");
( Y& F; E$ |/ p; _: ?  Q' nresult = m.find();
}

// Add the last segment of input to the new String
m.appendTail(sb);

: l, u: k3 K$ b' W, zinput = sb.toString();
! ?, A' q1 t1 u2 K9 i0 D
if (deletedIllegalChars) {
- B# z; p1 v. }  n  N& B4 jSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
, r( S8 i( z' T}
}
9 v( h1 \. c; A5 y4 ~) R}

从文件中删除控制字符
5 t5 T+ n+ q7 o
: m& f& d2 o! B7 @5 i; L) C/ `* i/* This class removes control characters from a named
( p  C5 [1 s# h/ Q5 U7 p$ a; S* file.
/ i3 [  f# l; g$ E9 M*/
import java.util.regex.*;
import java.io.*;
8 S, B, i: `1 `4 Y: V8 Y) ?
2 {$ ^5 M- _$ Dpublic class Control {
$ Q, U# W9 Q1 e( }1 Npublic static void main(String[] args)
3 y7 Y8 |: a  ~! P9 v           throws Exception {
           
2 Z- L7 P4 m1 W" X//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
! O  ~) g% q; R# g( lFile fout = new File("fileName2");
//Open and input and output stream
. d2 N% L; K; Q2 I: G2 mFileInputStream fis =
' X4 N9 K# ~+ {  U" \6 p* A- w- P       new FileInputStream(fin);
' E( v$ e9 A. f3 P, ZFileOutputStream fos =
       new FileOutputStream(fout);

3 L7 Y% o4 J/ DBufferedReader in = new BufferedReader(
  C+ u: {! d+ j/ w2 p     new InputStreamReader(fis));
( ]9 h. Q& A: ^4 ]BufferedWriter out = new BufferedWriter(
9 k4 h3 W& A# o8 C     new OutputStreamWriter(fos));
* ^1 y# ?7 P! E+ b5 ~
7 r* z( d% M# L: V1 n// The pattern matches control characters
8 `+ g4 F/ {; L4 JPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
5 g! i4 ~2 a# _5 V; ]$ \/ ewhile((aLine = in.readLine()) != null) {
m.reset(aLine);
5 r; M7 k* m& Q8 `2 a//Replaces control characters with an empty
//string.
5 j( H# ~' q2 }+ o  rString result = m.replaceAll("");
out.write(result);
out.newLine();
}
in.close();
; T" _2 i) r: g$ g4 D, nout.close();
; L) b8 _8 p+ F) {  {2 G6 h1 z}
}

3 d' [. f- e5 i8 a% D0 p文件查找

- |1 W! Y  f; `5 l' B/*
8 G/ x7 k' B' S; q0 v& O! |. {5 D* Prints out the comments found in a .java file.
+ L/ u/ z$ g" H( Y6 [*/
6 \5 |8 b+ i$ t* |4 r. Rimport java.util.regex.*;
import java.io.*;
import java.nio.*;
$ c& M1 C) Q" }import java.nio.charset.*;
4 M2 U8 y4 V# D* S" jimport java.nio.channels.*;

( ]9 E  B: u& z3 L% v+ tpublic class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
File f = new File("Replacement.java");
; N/ G  t' Q# T0 wFileInputStream fis = new FileInputStream(f);
6 O1 T6 t+ p/ U# vFileChannel fc = fis.getChannel();
3 V, x7 e5 ^8 }# A6 R- P) M
// Get a CharBuffer from the source file
ByteBuffer bb =
) V. o/ Y4 w& ^9 Zfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
  D2 K9 n8 e4 U* a7 }Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
! K. T; B/ S5 ]1 W. n. j, eMatcher m = p.matcher(cb);
5 q4 n1 V) r7 D, W/ X+ J; Jwhile (m.find())
, o( x& _, o( q( K1 J: f/ k- ISystem.out.println("Found comment: "+m.group());
}
}

结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
% W$ o9 A- {" I2 D9 k
. q- U& F: O2 @1 I8 AJDK1.4之正規表示式
written by william chen(06/19/2002)

1 h1 v- z3 t: g. n--------------------------------------------------------------------------------
* U  D$ ^6 H; T; U7 `  Q
% a$ y/ X) S! S: I7 Z, z0 u什麼是正規表示式呢(Reqular Expressions)

' H6 `0 S0 W" c8 l就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
$ ]4 `- [" a7 Q2 t" o5 q3 I
0 i$ g* L! I: E, T所以發展出一種特殊的命令叫做正規表示式
& M( [! n+ ]# F0 R, u$ t
2 r0 i) s0 z# }* w5 N1 D$ _9 Q: E) @我們可以很簡單的用 "s/
! H& J2 o4 y0 l% [6 ~因此jdk1.4提供了一組正規表示式的package供大家使用
- l$ G( _% G1 U, D  t) V6 R+ T3 o
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
/ z+ \% h! Y( @+ Z3 |  b9 G, {( J
"." 代表任何字元
6 m1 E# B' H5 H
正規式 原字串 符合之字串
. ab a
.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
+ ab ab
* abc abc
- A* J6 b2 v6 h4 S9 V
" Q, x4 A. m0 r; G/ W, d"( )"群組
- m) ~2 R) m" u: B4 m
& |; y; k- J3 U+ @! l  y9 f+ n正規式 原字串 符合之字串
(ab)* aabab abab
" ]* H+ A9 L9 B. Q
  |. @! _7 A! H/ h3 _字元類
' m4 G* C" x: x; n5 i) o3 v6 |" E+ O
1 \$ _% j" l$ N0 {正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab

" A7 Z( ~% c. r# C, {& y% P
簡式
3 x0 v* b) Y" m5 M! E
% Q6 J4 @, H& j+ |; D9 O" u% B\d 等於 [0-9] 數字
  H7 R( H& h& ^; d; B3 }- b\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
, q, C  X- J' u. ]' x0 }\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
; W1 B% D. U2 }$ ?# c\W 等於 [^a-zA-Z_0-9] 非數字與英文字

: P. l1 q$ Y- `9 j  V% B每一行的開頭或結尾
7 `  s1 X( i- p7 v7 }
0 y& D9 m- I+ U. G" }3 t^ 表示每行的開頭
8 x8 }' ^9 W! M1 W! e% R$ j8 N% K' {$ 表示每行的結尾

% Y: \/ F  `) O. X5 |( W  n, B( [--------------------------------------------------------------------------------
% c/ r7 m+ J" H. @; n3 f
. q( w! ?2 k: `$ X& [; t& i正規表示式 java.util.regex 相關的類別

3 w- m- Q. R% fPattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
0 K; m( Q  d/ q4 l/ d$ V/ S
3 T2 e4 B5 t/ k# D' p2 N範例1: 將字串中所有符合"<"的字元取代成"lt;"
) N3 y3 Z1 ], Z
import java.io.*;
9 ~; C( l$ C3 Aimport java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
// BufferedReader lets us read line-by-line
2 w$ q' ^1 A% N# }/ _5 p4 h& RReader r = new InputStreamReader( System.in );
+ O3 c. V; G: iBufferedReader br = new BufferedReader( r );
8 E/ [2 v) Z, q! a9 U6 K: g- T, P, uPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
( E  ]7 ]3 E. Mwhile (true) {
String line = br.readLine();
2 _- Q) g4 Y$ Z" `# ?// Null line means input is exhausted
if (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
. u! i7 n' O* C: W! RSystem.out.println("搜尋到的字元是" + a.group());
1 N1 A$ Y  P- w1 r}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
; {0 j2 X2 e; I# U. ^. h3 }}
4 d% y9 Z4 g; _- }+ G; W# J}catch(Exception ex){ex.printStackTrace();};
7 d# i1 t$ @3 X4 i& b5 o}

範例2:

, }& n8 E# M) \. t0 @6 ^. z0 }import java.io.*;
( T' @6 `3 D: W. h7 {import java.util.regex.*;
/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
8 c" o1 V7 ^" `7 D  q% Q. V// BufferedReader lets us read line-by-line
; M7 P7 n# k4 f5 W2 zReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
+ L! i  m$ E( H. h* |  u" ]: VPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
: y; m& p4 X) T" \# wtry{
. w  w4 ~8 A8 C/ ]$ e  swhile (true) {
String line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
# c) a" v; N2 L2 N. Jif (line==null)
break;
6 B' A, ^% {3 y// -1 means we haven't found a word yet
int longest=-1;
9 O! r: ]1 d$ `; M5 l. w  `int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
longest = i;
6 B0 h: @  ^. [longestLength = words.length();
}
, S0 @$ N+ |: X, j4 C3 Q% q9 R}
6 y1 z7 Y( w9 d6 }/ f( }5 dSystem.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
  r" {8 E3 T4 N$ d' X5 A" S. o5 C}
! [, C; a) [% Q  P, |) B9 e+ v, U
' i' ?1 G3 j) ^--------------------------------------------------------------------------------

; O# M# d, `+ {其他的正規語法

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

一叶

一头雾水