关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
1 N9 z" I$ Q, ~4 I6 m
$ q+ L: j' W7 C7 @: N; ]- ?支持多种平台
* H+ a/ q/ G0 a2 y; @
+ R/ A- M" c3 T% d
5 Y& f  O' G7 I  R正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
( T# o, ~) j9 ~( ]+ g
8 i$ D& E# Q2 r% Z# J8 B正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
  Q9 a  |8 c/ L& q) z
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
5 ^2 Q0 k$ }8 u
比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

& }  [1 ~  Z% J正则表达式101
6 T5 H7 b1 K) E- [很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
; f5 v6 o- A1 E1 m. M- k3 G
' l" ^5 ?2 w( f, W第二部分：
3 q# \2 M/ Z4 g$ f----------------------
字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
7 I8 K1 u, }6 H( w( {% j  i
2 O4 S$ {4 D- M- x每一个表达式都包含需要查找的指令，如表A所示。
: ]9 b5 Q! |% Y9 X+ a* d: ?# u; W
3 G  U/ N3 |3 ?& h/ G8 {4 i3 H, ATable A: Character-matching regular expressions
格式说明：
---------------
操作：
6 G0 y" z2 M  t: W/ Z2 ?/ S* H6 m解释：
+ \3 j3 `! E" T' y例子：
结果：
----------------
.
Match any one character
% Y5 M5 \  t! x, \" s+ z8 Ygrep .ord sample.txt
* t4 z. a+ ~; u, L* I2 Q/ cWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
& j, u# \! p( H; x! H3 k-----------------
[ ]
' S8 i3 P" h+ B; J2 x' w. D% xMatch any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
9 M" b" D- L0 A/ _& m---------------------
[^ ]
3 b+ ^( \3 z. w/ A" y6 b5 z4 y( _7 bMatch any one character not listed between the brackets
+ m+ R9 O* Y7 @/ _5 M* H
grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
8 ^: ^2 t3 A+ _( l* L9 x
grep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
3 T" X4 G5 [9 n8 |
. o) H; X- c8 b8 [' g+ Tgrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
+ I5 E" T* d; q2 X8 `8 _
) A, f; ?6 `3 w8 t. M* Q. \1 F% c! ATable B: Regular expression repetition operators
格式说明：
1 c2 s; }$ [$ z5 O/ C& T! e---------------
: O# M+ A3 I6 @2 ^' Q4 u操作：
解释：
+ w( f0 C, l4 l$ n例子：
) O7 t* o2 l1 e2 b0 J8 F结果：
----------------
?
8 i8 }: m8 i1 Y) d: F# S( m6 ]Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
2 U" w9 S: d$ T; o( ~' I8 \*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
+ ?1 g8 o8 ]1 _; D-------------------
$ J' H9 g. I, }5 O& A) x* T. t+ k+
Match declared element one or more times
egrep “[n]+erd” sample.txt
3 E5 \( ?4 m! |Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
- _+ s) J' O- X# S( _6 g7 P- `Match declared element exactly n times
- s$ N( U/ C5 f. i5 F+ e6 pegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
% y+ b4 h* c# L& C4 mMatch declared element at least n times
- ^' j( I9 H) gegrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
' @* ^6 t! [/ d& b, E------------------------
{n,N}
Match declared element at least n times, but not more than N times
# R3 o% L; K- E4 ]' k! `! Kegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
2 c  G" _' x* M% @+ j! C
第三部分：
----------------
. I5 a% |3 a8 y* f. s$ W0 i7 f锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
. y  m' Q; K8 u9 b# |0 a+ `
s/pattern_to_match/pattern_to_substitute/
( U+ q8 t+ U0 m$ R# K

Table C: Regular expression anchors
$ U8 ]8 W6 b4 r7 O-------------
操作
解释
例子
# V5 G2 S2 g% ]2 C9 Z* j结果
9 n' _2 o: v, V4 d---------------
* ^+ D: c7 r! ~. k^
$ M' A( h! y6 j9 p4 `2 C- e; `Match at the beginning of a line
/ S& V! k/ `% {3 ?' cs/^/blah /
Inserts “blah “ at the beginning of the line
# Q4 u- H! i7 |% E---------------
$
' _  @) E+ R5 V$ q( _% DMatch at the end of a line
s/$/ blah/
9 P$ U5 \/ a2 _5 D. q( LInserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
/ F8 r. }* _' K# S: x1 R6 h
egrep “\Matches “blahfield”, etc.
------------------
% U+ K8 t1 l8 }" Z1 B\>
+ _7 y0 ?# p  W6 y; Z/ BMatch at the end of a word
5 I. P* p$ V/ g4 F( e: l+ o- U5 @s/\>/blah/
4 `: S% _$ s; B( d2 ZInserts “blah” at the end of the word
* H1 M0 L% J- E* o5 I
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
8 d" P7 L1 Z+ Y8 s---------------
( b  F# Q- {: u2 X6 w6 r, x3 [9 b\b
Match at the beginning or end of a word
, f2 r) B7 L" }* jegrep “\bblah” sample.txt
: _. ^  ?6 \+ W( E; t3 XMatches “blahcake” and “countblah”
. K$ B* {! N! @' x' Z: k: m1 @-----------------
) y. x- e  N9 d7 n2 [* l# `\B
3 w! G* t( b2 o7 ?& W! ~3 a3 CMatch in the middle of a word
6 W) N" {) q5 b3 H3 Iegrep “\Bblah” sample.txt
Matches “sublahper”, etc.
7 F/ g) ?- c$ e0 H/ {7 y6 G, \
间隔

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

egrep “(n|m)erd” sample.txt

  B1 }0 Z$ O% J  t间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

& ]  N4 {" b- s! A! Xegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
1 L. S) w8 W7 m3 D  u
2 L: n( l' T: L; O/ t: r- Y& }第四部分：
----------------
1 q0 M& d4 o5 F2 ?0 B' X一些保留字符
1 p3 ?! B9 U# B& m2 DRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
) z) @. s, \! a# E5 h  i. g. b) x
^ (carat)
. (period)
9 \: n. I& D0 V) a' R[ (left bracket}
; Y  `! E/ W. H0 ^( `& H$ (dollar sign)
. }4 P1 Y: m, l( v: F' C$ t( (left parenthesis)
) (right parenthesis)
6 R8 y0 v; w& V| (pipe)
# V7 p5 b+ W  ~- K" t* (asterisk)
+ (plus symbol)
0 r& v% K% D( e! W9 N9 V? (question mark)
{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

6 g* Z) k  c' D! B' \* Eeregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
: J' ~# b0 L0 l: O
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
; M  h: ^* w& u% a, E
/ V+ |+ a4 s+ r# C$ X: @: c总结
/ U' O" [  t3 x$ a6 I- P* Z1 K" q在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

另外一篇文章
----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法
% E. B, G* @: i1 f  o( w
% m) M; n- ^' J; x3 b1 P下面的类根据正则表达式指定的模式，与字符序列进行匹配。
' c9 L3 c8 V; I
Pattern类

  R& ~! h0 X" zPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

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

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
8 V1 p6 U( T6 f! v/ s" @
: J' W6 r$ j$ x+ }8 H" M$ z1 zsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
, B; R; |" a$ o  v
/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
: O0 b% Z4 Z$ `  L5 m9 R: Zimport java.util.regex.*;
$ [- ]& a; v4 R+ q5 V. k
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 =
  B, ?) @' J- V3 D1 |9 A" j   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
& f( q0 a7 ?+ ^( _8 L}
% K9 F) m) H5 z: C( T}
7 H- r* Z; M/ \$ D" ~
Matcher类
* t2 }, d3 C# z; t4 N
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
; G$ p" U) a5 w* n4 S+ n
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
! O  h5 B$ l  h+ l! |- Z3 e
; d  a1 ^- X% L) Ematches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
2 \1 \# A8 O, Z" b; t7 y1 g& U" Ofind方法将扫描输入序列，寻找下一个与模式匹配的地方。
( Y# c8 a# u# _; W) x8 u
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

! O* N8 \% \, O. b8 `( s2 f这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
( W# h: Q* ~7 `# i0 [# v. }
! E* Q' W$ u0 k( C9 T0 @- W2 {例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口
0 n, m$ L4 h0 G5 k) k/ l
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
6 v0 ~" d/ t3 S! h
, ~" m; b0 Z4 j6 URegex情景范例
$ m! S$ o* i0 l7 M5 I% H1 R4 e5 ?
0 `% {' V" N4 A以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
/ R+ U, A, i# K+ L7 K2 ^; H% B
) b1 J8 \5 c( _" t/ [9 x. ^5 B/*
4 X: O# ]+ C1 U* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
import java.util.regex.*;

+ ]1 C- E2 y0 _1 g9 jpublic class Replacement {
public static void main(String[] args)
9 G9 d4 }1 c3 v8 e; e       throws Exception {
" Q! {" G4 D' {+ |// Create a pattern to match cat
6 p5 A: `4 R- p8 r  J: ~2 J- S6 u. ZPattern p = Pattern.compile("cat");
// Create a matcher with an input string
" D- E6 c! q# [5 H+ |Matcher m = p.matcher("one cat," +
     " two cats in the yard");
6 A* m; s1 C/ s2 v: \StringBuffer sb = new StringBuffer();
boolean result = m.find();
: R/ Z# D6 S8 b) w8 h// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
( U6 K% Z* T3 q5 M' k: Eresult = m.find();
}
// Add the last segment of input to
// the new String
9 |$ x4 f' T0 b: q- k, i6 wm.appendTail(sb);
System.out.println(sb.toString());
}
}

电子邮件确认
* C7 Y3 w9 K2 q9 i7 M" S
7 R2 ]: I9 M6 F! u+ o1 S8 f以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
1 Y! }, G  W9 V; G6 f( r
# t2 k; a% j9 Y# f9 S/*
* Checks for invalid characters
* in email addresses
+ E9 h$ X' ^3 V! h0 j*/
public class EmailValidation {
& L& j' G1 H, y9 y& b7 Qpublic static void main(String[] args)
# ]. N. V8 o9 p0 B: ^. z5 x) U           throws Exception {
6 b& P3 T9 w4 H* A8 \           
String input = "@sun.com";
//Checks for email addresses starting with
6 p1 N$ i0 f' H+ h% k% y1 Y//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
' v5 O; j! P* N# Z1 qMatcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
  f1 a2 [( r; o- Q6 z9 B* v! ?         " with dots or @ signs.");
//Checks for email addresses that start with
% p  a8 D, y- v3 o; K+ B8 Q//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
% l( c3 P. r2 {! T3 Q& H' aif (m.find()) {
) f9 j6 o# E- O9 I. ASystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
" z; W* u, K0 U7 J}
  a9 G' j- d% }1 O; {' o) f$ Mp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
: ^/ n7 y9 a# T7 r& T' rboolean deletedIllegalChars = false;

while(result) {
/ X+ P# K' b( BdeletedIllegalChars = true;
m.appendReplacement(sb, "");
- `3 y1 l$ S! K2 g( Rresult = m.find();
}

$ S& K% B1 L6 Q0 A1 d3 P// Add the last segment of input to the new String
) b5 o/ O! c  Z. C3 um.appendTail(sb);

input = sb.toString();

- t/ K1 |& m9 Nif (deletedIllegalChars) {
2 {% I$ j' J: \0 }( I. g  USystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
3 k1 r2 \" m- _' l}

从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;

  {, l# S8 C5 p4 U+ Upublic class Control {
public static void main(String[] args)
           throws Exception {
           
//Create a file object with the file name
- q' m7 x' W! T+ C//in the argument:
File fin = new File("fileName1");
: C5 ?& z2 ~' YFile fout = new File("fileName2");
//Open and input and output stream
( M/ U, k1 ]% `9 D4 w8 XFileInputStream fis =
       new FileInputStream(fin);
# ^% `, f) \3 m$ IFileOutputStream fos =
" e* ]1 a- D0 a: b( e       new FileOutputStream(fout);
# q8 z0 C# j' P
BufferedReader in = new BufferedReader(
. }2 E' w2 A8 o0 B; O     new InputStreamReader(fis));
8 F& A7 n3 V; Q( rBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

, S, Q$ P/ [- U, H& m" `; b) L// The pattern matches control characters
6 X$ n0 F# j* \2 A$ `3 G/ j  vPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
5 h8 T. q; V0 r" t9 `String aLine = null;
0 b- N2 B; h! h! j% I9 J8 P6 ?9 Mwhile((aLine = in.readLine()) != null) {
, |. p3 J- L# K' V! [: @  km.reset(aLine);
& h( X' |5 ?  G4 a9 E0 t8 w//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
. }) [1 s$ s" z- C, W4 Pout.write(result);
% M8 J/ h6 E4 f& |9 g5 g5 z3 S1 fout.newLine();
}
in.close();
out.close();
}
, l2 T! d8 q% g}

文件查找

, K( h$ [+ p+ K" k1 ?! [/*
* Prints out the comments found in a .java file.
4 f" B/ W' G) b6 |*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
* F5 w" x) E+ {Pattern p =
% R0 A! z' [. i+ J  oPattern.compile("//.*$", Pattern.MULTILINE);
4 T! D( F0 p# u+ \6 h' C
// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
4 t$ w/ J  J) M, M+ q# `FileChannel fc = fis.getChannel();
7 @5 v; `5 j, g9 h5 V, `8 {. B
2 E1 D* W* w; p6 h0 M/ F8 r, y// Get a CharBuffer from the source file
; y+ e* {1 ]8 `( lByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
- v3 Z" P5 L7 xCharset cs = Charset.forName("8859_1");
- D! W% R8 x! hCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

' e, F. g; ?# ], G" B" ?// Run some matches
- C4 t, @2 R9 ~- f% \0 R4 k! M( I" CMatcher m = p.matcher(cb);
while (m.find())
4 q9 H6 c4 m7 B& ?2 j8 NSystem.out.println("Found comment: "+m.group());
2 ^1 g6 H$ ~0 Q, c, e7 S5 A}
}

4 B! ?/ N% o6 S# `) S! G) C/ Z结论
: f7 U* f* t8 W  Z现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
" _2 R& g+ y; g3 Z: z: l) D5 S* @( g
JDK1.4之正規表示式
3 ]) y% m; ?9 a5 Cwritten by william chen(06/19/2002)
. k- {3 `: {4 ?7 q% c6 J- Z6 m- H
5 e0 _( e$ Q0 X9 b  W# ^& c--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)
, ?+ J" X. k8 ~. Q4 F4 H1 J: B
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
! X0 X/ [2 j) r4 }5 g" o, U
* `: O, `0 g$ y6 d因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
) I& r$ {1 Y2 C
9 u1 K- b% o7 o+ N8 s6 L所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
% B) ^4 J, }4 e8 Z5 P* ^, y因此jdk1.4提供了一組正規表示式的package供大家使用

$ D- o2 M" v  Q若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
1 p& X4 k3 H/ i$ v( P# b" @+ V
剛剛列出的一串符號" s/
4 d" k) n. [, |' X" e/ k8 [適用於j2sdk1.4的正規語法
: m- \  u8 e4 t* o
"." 代表任何字元
7 ^* K5 w7 t" V  x2 Z9 n6 k8 u
正規式 原字串 符合之字串
. ab a
.. abc ab
0 j- ?) z3 e7 B- x" N; E
+ w& R2 \- Z- x3 P/ f- r"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

2 L' m0 o. I4 [6 ~* ]正規式 原字串 符合之字串
+ ab ab
' [( m  P. }: S% k$ h2 Z6 }8 N; Q7 @* abc abc
/ p3 |& P; T: d6 r2 b8 C
  n, l6 s# Z9 \7 D"( )"群組

! K, I6 `" p" f- v6 W正規式 原字串 符合之字串
- u9 p+ s% d' y! k8 S# \- x(ab)* aabab abab

. y3 j9 ], m) s* u字元類

" g* x! Y& `2 v+ l6 o" C6 l7 A8 v正規式 原字串 符合之字串
! j! Z' \* K. C' S[a-dA-D0-9]* abczA0 abcA0
: T4 A/ p, l4 s( `$ T, T& q[^a-d]* abe0 e0
3 W0 v$ C  S) Q; u[a-d]* abcdefgh abab
' |4 K: Q# o9 e
1 D; X5 J0 J) j3 R
簡式
6 Y& Y6 R: T# y  L5 U# f, d
\d 等於 [0-9] 數字
7 B* S$ n- }% j4 E, s* E\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
5 {. B9 Z9 g% D\S 等於 [^ \t\n\x0B\f\r] 非空白字元
9 s. x2 \6 w9 o! S\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

! c1 x8 j  e& V2 ]1 d; d! g" |每一行的開頭或結尾
" F1 X6 w% j& l9 ]% @- z( @
" t# ]+ t' ^1 N3 D2 H' f4 x^ 表示每行的開頭
$ 表示每行的結尾

--------------------------------------------------------------------------------

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

/ P# N; y$ J  k& C' V" jPattern—正規表示式的類別
0 Z8 e6 I9 b' B) Y2 ^3 R4 KMatcher—經過正規化的結果
' Z( s& \- O7 a( zPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

範例1: 將字串中所有符合"<"的字元取代成"lt;"
0 T7 a7 |9 o6 {3 m9 s
# d" @8 F& p7 _4 Jimport java.io.*;
import java.util.regex.*;
+ Y$ @1 B) L$ S) o* q! O6 U  d/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
// BufferedReader lets us read line-by-line
; L% v+ \% k! ^, L2 a1 [Reader r = new InputStreamReader( System.in );
# |, M6 B1 W8 q4 n, B% KBufferedReader br = new BufferedReader( r );
7 j" m  }/ C2 f- J) wPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
1 k& \/ a1 B  D& \6 f9 t: X: m: BString line = br.readLine();
// Null line means input is exhausted
* V, Z3 a+ v  c0 u" S* pif (line==null)
! I! j" j" x5 ?# q4 D: vbreak;
7 f8 k# a$ r7 j( y' D4 \Matcher a = pattern.matcher(line);
while(a.find()){
. N+ _# d4 Z) J  M% bSystem.out.println("搜尋到的字元是" + a.group());
}
/ R) w6 b& i1 f; h; E4 F4 {System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
}

- a/ j9 d7 L/ p* S$ ~範例2:
  n, M7 g1 k) A7 Q) k" |0 L4 ~
- e/ n, T- x, ^# F) Q6 P& wimport java.io.*;
import java.util.regex.*;
/**
9 l% e/ `! ?7 i6 z9 G* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
; o; P, c; U* C% m: W// BufferedReader lets us read line-by-line
, [  I. u' ^4 v- m) O; _Reader r = new InputStreamReader( System.in );
' w# j7 y7 [; }7 _, N+ A( h" I2 ?BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
0 J6 [( _  m  Wtry{
while (true) {
String line = br.readLine();
! R% m: ]7 ?* A, W$ u! `String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
+ c* e7 B7 J8 `break;
5 [# Q2 U8 `& w) j8 e// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
) [. x% x# l+ Q. r  _' r9 yfor (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
) V7 c& `; ~% J: J. elongest = i;
longestLength = words.length();
  A, u( Z* y) ?' M0 ]3 |. ^4 Q}
}
System.out.println( "長度最長為:" + words[longest] );
}
6 y; l8 Q1 P0 z+ k3 u}catch(Exception ex){ex.printStackTrace();};
  N3 ]! R' A# c}
  I. U! a$ Q7 q8 E& f+ t
--------------------------------------------------------------------------------
. ]4 l% m. t9 g! j
9 P1 v3 p' Y8 ~; U其他的正規語法

% V' Y+ C! `" y& Y& r& \& `/^\s* # 忽略每行開始的空白字元
7 k$ \0 A& Z: [/ V( j8 P(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水