关于正则表达式---ZT

Longe

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

; H# }+ y' o& o$ F  }支持多种平台

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

, f- k5 X) O+ I正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

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

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

第二部分：
----------------------
字符匹配
" ~, Q( p4 }8 n
4 ^7 O, U+ H* [9 f. ]  e8 L- G正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
* J# y: C* a: \- b1 U: [; Q- z
$ O6 [: @' q- M* A0 o每一个表达式都包含需要查找的指令，如表A所示。

2 S* v$ {) E" v  ]3 E! y" uTable A: Character-matching regular expressions
格式说明：
# H' j( F8 s% K; y# _---------------
操作：
' M6 j9 E. u( Q1 \) r解释：
% U2 w0 ^1 v* T, d3 L, L5 e例子：
3 w' J# X4 h; I- R( p, i结果：
3 i; c3 K. K2 }  k6 T% p2 F! P----------------
6 r" V* s3 o! C7 @$ R.
$ ?; F, q1 {. H; T% P3 e3 Q! |Match any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
) t) C3 m- n6 ^7 R6 z-----------------
[ ]
" \; o! E6 y( FMatch any one character listed between the brackets
grep [cng]ord sample.txt
( c9 e+ g/ H+ s1 Q# GWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
3 U: f: i$ e# f4 }Match any one character not listed between the brackets

grep [^cn]ord sample.txt
/ Z6 d: q5 c1 w( P! i# {Will match “lord”, “2ord”, etc. but not “cord” or “nord”
% R( a8 P1 q9 M
grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.

- F+ d/ f' H" O! L  B+ @grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
  f6 i* F% i3 G
$ {# u6 c/ h" \  ^0 H2 I6 N9 x, w重复操作符
* k4 @5 Z) x3 x3 i$ \重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
* w' G7 j% b' {6 G! B6 W3 A
- Y9 q# u# a4 S# J5 s9 i/ \/ L' C4 xTable B: Regular expression repetition operators
格式说明：
. [" ~) o% a6 f/ e, ?---------------
$ O8 A3 o( S8 `操作：
解释：
' O% E* G- {& m2 @( d% I例子：
结果：
----------------
?
Match any character one time, if it exists
! q1 i' y5 V8 y$ Uegrep “?erd” sample.txt
  P! ~9 i: o* l8 m  N2 sWill match “berd”, “herd”, etc. and “erd”
$ U" y9 A0 J4 ~9 S7 W' i7 E* r------------------
$ [. `& Q1 a7 Q*
3 L/ z) Z6 ~, t* ^9 }Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
8 E6 i# D4 d9 V: R* Z5 \-------------------
+
' B6 R5 t; \* B8 {4 H! e8 b( c8 JMatch declared element one or more times
egrep “[n]+erd” sample.txt
3 A$ y% G9 b* [  e9 c+ Z/ L& a$ g9 fWill match “nerd”, “nnerd”, etc., but not “erd”
8 ?: W" W8 U  q# N) \. t& g& E+ N/ N--------------------
8 `& r. j- c- c( p# J" {5 w4 U! m{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
8 G# U; z8 f8 ~8 |( }9 H" }egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
& @6 t, R) o0 w7 S3 Y{n,N}
Match declared element at least n times, but not more than N times
! n/ p, h9 g* ~3 t+ I/ wegrep “n[e]{1,2}rd” sample.txt
7 x8 ?" M' i. g+ M5 D6 CWill match “nerd” and “neerd”

第三部分：
, k! ?  b1 f0 b8 S" g, l+ f" D----------------
锚
2 u. v7 W7 a' [7 b. i1 b- B# `3 i锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

' n6 x; Q* W8 e' S2 ss/pattern_to_match/pattern_to_substitute/

$ V( ?" r* g2 h. c6 i8 B: d  _. m
2 g5 T" A% S! m1 N1 n$ `3 e5 N) DTable C: Regular expression anchors
9 V# {3 l* {, v-------------
8 K: q5 U6 z; [9 Q5 N操作
解释
! a2 ~1 Z# y8 f% W- \例子
$ [0 Y" J/ z1 p0 j' _5 i结果
0 s6 X9 J4 x# `( z2 _  ?---------------
^
$ a1 R  P; z; k6 @' R# JMatch at the beginning of a line
! ^& k! o0 @/ ^s/^/blah /
& l6 |% l# Z% G: X4 v' C6 VInserts “blah “ at the beginning of the line
, ~9 O+ F4 F1 ^! K; C2 ^) Y---------------
$
Match at the end of a line
; K, X/ b% r% m, B' J7 w+ d- t7 Ys/$/ blah/
Inserts “ blah” at the end of the line
% F0 S8 ^$ v2 q+ u% {* M4 _---------------
6 y1 r) P- z3 F+ Q+ T% Z\<
( P8 J. F+ v6 v  p* u9 Y( RMatch at the beginning of a word
# Z% r! ?2 W  as/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
\>
4 t% `: f* P% i2 _; f# `Match at the end of a word
1 {, _# x4 i6 R  f' ]9 M/ js/\>/blah/
6 i5 N8 N* T8 mInserts “blah” at the end of the word

egrep “\>blah” sample.txt
4 P1 Y; u5 A/ ^# {% I2 Z8 oMatches “soupblah”, etc.
  N1 f- R% H1 q8 F---------------
\b
1 F: L( _( r( r0 g9 a" q- A$ vMatch at the beginning or end of a word
egrep “\bblah” sample.txt
$ E2 M4 }% a  W. @& m( JMatches “blahcake” and “countblah”
9 x' s/ K4 e- `-----------------
\B
3 D2 f# S' P  BMatch in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.

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

% B: q+ J- }: z, k- E2 U% `egrep “(n|m)erd” sample.txt
. R: T. b; V7 n! z. u4 b+ T: Z3 p
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt
/ Y) n* W& i! G& [
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
( G2 d& j  {1 `
第四部分：
2 s; _3 J  l% Y----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
# g7 h" F/ h) s- H1 ?9 I
^ (carat)
4 U! m3 S) G! T4 W. (period)
0 r' j3 \8 B2 ]( ][ (left bracket}
6 S, F" m9 |5 l$ (dollar sign)
( (left parenthesis)
6 ^% n( W) R# @/ q& M' v) (right parenthesis)
: C& Q( I) A4 t. s; R, _2 w| (pipe)
: k# z7 n" Q) c4 q* j3 O* (asterisk)
7 O+ l, {+ Q% z- \. f7 X8 _+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
+ i. H6 ^- g, E9 t\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

: T' y4 B, o; H+ _0 L( leregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
& M. U3 E4 u* d! o6 A8 T9 v7 J在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
----------------------------------------
2 U: }/ c3 D: G) r正则表达式和Java编程语言
-----------------------------------------
类和方法
$ Z( f6 E7 C- Y9 y
# J* X. @. ?' K3 @1 n下面的类根据正则表达式指定的模式，与字符序列进行匹配。
9 F1 I* i9 Z9 t; U$ P/ M6 U
Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
- G) N8 l1 r% o; O9 H$ w  b- n
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

3 }, |! `) S/ ]+ R2 ]; ]9 f% \用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
$ W7 O  G6 |: e4 [1 s1 [
0 P4 P) L) s* \, M) t. l* ysplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

4 J: C) k& n3 g% k  S; \/*
  `. {5 j3 P. j" L  d% w" f- Z* 用split对以逗号和/或空格分隔的输入字符串进行切分。
% ]1 L- j/ L; E( J$ J- Q# S*/
import java.util.regex.*;
7 o! C9 m7 H1 [# g' N9 \/ f
public class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
/ r0 O5 m, y# e5 p' E// Split input with the pattern
String[] result =
* N7 A$ X6 w6 G3 i$ g( c   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
! }5 Z- W1 b4 s- a' }  _5 o}
}

" y4 e0 }5 k2 T3 {8 n; fMatcher类
$ X" B- `3 l' E, u6 v
! {' f0 r6 W  o% G7 Y1 Y3 rMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
) ]& k" M5 }3 a+ }! L: A" c
+ t: [4 k' H  L4 g& j5 @7 x/ n! Xmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
: ?1 y& V: |2 P# Q1 U2 bfind方法将扫描输入序列，寻找下一个与模式匹配的地方。
, }  u2 d% j) x  b' d- o# ^3 q
& W4 D/ O1 s+ P6 _这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

: g6 T/ }, U1 _6 }0 C这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
3 Y/ b8 l- @) f6 K1 _4 l
- l8 B2 s4 j2 B: ]appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口
9 V" a( l6 x7 L$ R! s: o1 I: i- [
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
; I8 X% h4 A6 L4 d1 I; U
Regex情景范例
/ H( j# u7 r5 t# b
" X. m) e- }: I( s& P3 _6 a/ [4 D8 K* U以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

0 o, t; j4 h/ O$ A% o) U9 r  g  l简单的单词替换
# U! |1 T* l8 \/ c% o
& [4 X% I$ t) }3 b  \/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
4 [, Q" n7 v- l' S! K  c" M*/
) O& c! Y; O* h* |& q% ?7 Rimport java.util.regex.*;

% c) z8 v+ |; fpublic class Replacement {
9 y3 {# S. j/ `5 l5 g  @public static void main(String[] args)
$ _) `1 @+ t# |. D: B       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
/ V: f1 X0 S2 J. Q; u# H// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
" D6 N6 K9 N  Q# h' bboolean result = m.find();
// Loop through and create a new String
" d5 F8 @7 I2 g# {// with the replacements
9 u+ E9 N& q! vwhile(result) {
m.appendReplacement(sb, "dog");
. {8 }, S) l- ?6 Nresult = m.find();
. [) `! v  Q8 x9 J" `0 M# k. X}
/ e/ f+ v/ e, O# F5 d8 ^// Add the last segment of input to
" t7 [7 p/ P; [6 q// the new String
5 K, F8 X/ c7 l' Q/ Fm.appendTail(sb);
+ i! M, U5 m4 M( H, u* R1 XSystem.out.println(sb.toString());
}
+ Q2 W1 e" D& C0 z' S) R}
# D' E' ?% \! G% S) z- d
电子邮件确认
4 E6 E& S1 Y. {  c8 p$ m5 t
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

! g; W$ H; z& f5 G6 O/*
; }$ l! W5 r3 |0 e& m# L* Checks for invalid characters
# Y: b2 I6 K  x) ^, I: a' Z- x* in email addresses
*/
public class EmailValidation {
0 g7 n: W" f0 }public static void main(String[] args)
" t( A9 z6 ^' K3 J           throws Exception {
           
String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
6 h4 E4 n; E8 P6 ^! MMatcher m = p.matcher(input);
" ~/ X. P& \8 {2 o, s6 M2 Lif (m.find())
System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
7 j+ `$ m) l% r! @# E  Um = p.matcher(input);
if (m.find()) {
8 k; h2 [0 V; f* o" \# ?System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
4 ?5 u# L! R) N& ^6 d/ u}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
# q3 z2 R: b" XStringBuffer sb = new StringBuffer();
boolean result = m.find();
+ Q4 z  V( w# x* ~4 b0 Uboolean deletedIllegalChars = false;
( c& g- v3 V; A& D* p4 p
while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
& F; {1 D9 n' i3 t}
+ W$ _- D1 w' N: d: M8 ^
' ]8 |5 D" F/ F' M// Add the last segment of input to the new String
m.appendTail(sb);
& E% M) i1 T# L: r1 G5 b  Z6 t# S4 ]
input = sb.toString();

if (deletedIllegalChars) {
* j+ [' W# S. N- R5 I9 {System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
  }' q# d5 }$ ?5 \5 V}
}
1 p0 }0 R- [6 i( }& i) Q
4 V1 [) u& e- u, C3 R4 Z从文件中删除控制字符
+ K) n4 S5 m9 t- `
5 f+ q" O5 g' L$ Y% k/* This class removes control characters from a named
) Y* L2 `" M6 K4 J3 R$ k: s& j" K+ M; Y* file.
. U# u9 g  z/ ~' X; g; k0 H*/
import java.util.regex.*;
import java.io.*;

public class Control {
public static void main(String[] args)
           throws Exception {
9 M" e6 t# `$ x/ z/ W3 z: u           
//Create a file object with the file name
//in the argument:
5 f8 {, t* B/ k, p& MFile fin = new File("fileName1");
File fout = new File("fileName2");
2 i) v' ]* A# i4 [' ^# X//Open and input and output stream
FileInputStream fis =
* ~0 a7 n9 [0 e3 _8 t       new FileInputStream(fin);
- O! _7 D: {/ ?  s2 z8 O! @" YFileOutputStream fos =
8 C" n- H1 }$ p! y* Q& [       new FileOutputStream(fout);
0 A5 D2 D; Z8 _& ^* Z) ^
+ }6 z1 z- Y; C6 W9 ~BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

// The pattern matches control characters
' L2 P" _% ], H! [0 T% F5 o+ QPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
, G% b/ K4 K$ wString aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
& T7 H/ J; h- h* r# l9 p  L5 I  S//string.
' z. |1 ]2 B) R* lString result = m.replaceAll("");
) _! t/ v3 j5 _$ U, xout.write(result);
out.newLine();
/ u3 z& X" m" D. M6 W& [" z}
in.close();
, k5 h& K' p' Y: rout.close();
}
9 j4 ~& N" H; k3 W+ w}

文件查找
5 n- Z2 J% [( l' F7 T- U; I
6 F/ ~- _& h) ]7 b& ?8 k& n! y/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
+ ^' i: t' L: D2 @/ `
public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
; X" F/ l$ [, y% p$ W* _& ^: JPattern p =
+ T' J& C8 \6 @2 P) P3 d) |Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
4 B: x: [% t0 I+ q8 {, uFileChannel fc = fis.getChannel();
$ R, |/ S$ ~. U5 E* T% W
// Get a CharBuffer from the source file
ByteBuffer bb =
7 q5 ~. n3 A) j% s, ~& O3 u7 v* `fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
7 C# E0 Q4 p7 H- a9 ]" ECharset cs = Charset.forName("8859_1");
0 |6 u  ], {2 f- r/ KCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
) E  `/ e# S$ k7 c- e' L
// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
}

结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
9 E9 c! Z7 n2 _  S* r/ X  n* i0 {9 Zwritten by william chen(06/19/2002)

7 q# C* `! q8 k9 p--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)
% e% ~  b# L' \1 P2 O
就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
6 s/ y# S; ~8 H  K
所以發展出一種特殊的命令叫做正規表示式
- {, N8 Q" A5 H: e* N
0 _9 v' M2 N$ y8 w/ d8 G, Q$ u我們可以很簡單的用 "s/
* f) |% z+ d; R& B+ j, v7 B0 @因此jdk1.4提供了一組正規表示式的package供大家使用
1 d" a) N3 }% ^& j! T0 c0 _+ D
5 N; d( ?% q9 U0 Y若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
2 s/ K6 Y# W$ u- Y$ K/ [% e
剛剛列出的一串符號" s/
/ E2 ^2 u( Z% s# N& h4 z& x適用於j2sdk1.4的正規語法

' l+ O$ C: {3 b  ^7 e1 ^! e"." 代表任何字元
% e, h$ m6 {) f, W: k- ~, E$ V
正規式 原字串 符合之字串
. ab a
& J) y0 D" p) |( D$ T, T.. abc ab

8 i3 G, r, x# k"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
3 z8 ^- ^/ p; u( D5 Z% P- d' }
正規式 原字串 符合之字串
+ ab ab
* abc abc

"( )"群組
, p: s0 N, J! _
; O  ~- ~, m5 {8 G& A/ L正規式 原字串 符合之字串
0 A$ ]. M* O8 y. T+ d6 o  d8 Z(ab)* aabab abab
, Y* @1 b! z- [, K$ s
字元類
! q2 y5 J  s% V$ g/ d
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
" U! G3 x9 E2 i% v[^a-d]* abe0 e0
( S  G: _6 b& d" P[a-d]* abcdefgh abab


7 j* A+ d) V% N; u簡式
! r8 N7 l1 H1 X6 j9 }
4 T0 i, e. K' v\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
/ L1 z( h. O, \\W 等於 [^a-zA-Z_0-9] 非數字與英文字

# i/ F$ P7 s- w3 F! L$ x3 k/ d每一行的開頭或結尾
& d! V  C# S- C
  J8 m- u3 x% f; d^ 表示每行的開頭
$ 表示每行的結尾
- S& p, w3 @5 Y' j7 _
--------------------------------------------------------------------------------
+ n+ C2 R2 @  H' a
: f  f( N6 I  }* l1 N+ C正規表示式 java.util.regex 相關的類別
6 R0 q6 W3 Z8 P: U/ T
Pattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
- t6 B+ g& G( e  U' l( Y2 j. D
. e5 W2 }& X6 u* J, O: _: c+ }* j範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
import java.util.regex.*;
/**
- Q" c# L6 i8 K+ u# t: j# Q* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
// BufferedReader lets us read line-by-line
; l: R5 [8 A  rReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
1 N8 W5 R: d" i4 v2 l! ^7 htry{
while (true) {
String line = br.readLine();
, ?+ o3 \8 @# A- j* g9 l- b4 G7 N// Null line means input is exhausted
" G# K( ~# o3 |& W( b$ Kif (line==null)
1 M0 z0 z1 f- Q. U- m2 z5 Dbreak;
, y/ Q9 i. r2 i. r5 p+ p7 [Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
' Q% p3 y( B: d" u. t' q}
% S5 e, `$ z& K* ^  l  B
範例2:

  M: J4 {" T, y! z$ r6 bimport java.io.*;
% k" [  [; a$ z4 @  g$ h! l: z6 mimport java.util.regex.*;
/**
6 Q/ R) W+ {. x7 c* 類似StringTokenizer的功能
4 [1 H, T& @- m  ~7 X9 o2 L* 將字串以","分隔然後比對哪個token最長
! H+ c, T" A% k' r; U*/
; s# t: d0 o: R7 Mpublic static void search01(){
7 f8 J/ j) _1 B: d9 d// BufferedReader lets us read line-by-line
" _# E: U+ @$ o# o& dReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
% h9 t5 o8 `/ e4 IPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
; ~/ Q6 r% L3 itry{
while (true) {
9 k2 k4 v9 L0 U4 p. ~String line = br.readLine();
String words[] = pattern.split(line);
( U9 W: L9 u. K, n9 X1 R$ R// Null line means input is exhausted
8 f: T+ f0 o3 f8 G' E" d  E9 R% V2 dif (line==null)
break;
% }3 @$ F, d( m// -1 means we haven't found a word yet
int longest=-1;
! ^; p, m/ W  |1 Y9 i" m3 hint longestLength=0;
4 y7 i" D/ `. `2 v: J5 I3 Vfor (int i=0; iSystem.out.println("分段:" + words );
6 z; Q9 l; U, Fif (words.length() > longestLength) {
& `+ N; ~7 A8 C4 Flongest = i;
1 S1 M% ?, A% f; R; OlongestLength = words.length();
}
/ ~- _3 w& T, k8 [. `/ L! x9 K* N}
+ J# Q( m- S( ?# T. k. |% @System.out.println( "長度最長為:" + words[longest] );
/ C: g# v3 p  ^}
}catch(Exception ex){ex.printStackTrace();};
}

! ~0 J/ G, v6 c( F! a/ G6 w--------------------------------------------------------------------------------

其他的正規語法

: F7 P( u! U0 a0 N% m0 y8 v/^\s* # 忽略每行開始的空白字元
. u# E+ N! H# y' M(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水