关于正则表达式---ZT

Longe

第一部分：
! h( p$ \- [+ e# L: e7 a' x6 D-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
7 |0 H7 f- d5 i% L; l
支持多种平台
5 H6 S( N4 n& r( j; C

正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
* r6 H3 {3 p" u, M
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

6 V: W' n& L4 n7 k* N4 E" G# z/ m3 m许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
" A/ A. U7 N" |- E$ V3 v
* z& z* K9 f$ V/ `" `% d比你想象的还要普通
) i3 j4 E5 a' o  `8 j% N随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

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

- S' J/ w( v) z第二部分：
( i. f! J1 G3 l1 D5 N----------------------
字符匹配

% j2 V9 P  I$ H4 p2 b+ [6 t9 [正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

: j) f" w& q" H& |5 b, I: Z9 }每一个表达式都包含需要查找的指令，如表A所示。

Table A: Character-matching regular expressions
格式说明：
---------------
操作：
6 ?" G. O% L! D% c. E6 J解释：
例子：
结果：
8 D% B6 a( R- b5 w3 Y----------------
& s0 z7 e! [2 E/ ~0 ?6 I, \, I  f.
Match any one character
5 \1 ?: S( s5 U+ M! |6 h4 kgrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
: w2 o9 d  D& Z" p2 O; p6 h6 N[ ]
Match any one character listed between the brackets
grep [cng]ord sample.txt
% r1 ]' c" M/ m: \" U8 t1 qWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
Match any one character not listed between the brackets

grep [^cn]ord sample.txt
6 u: S0 A6 I: bWill match “lord”, “2ord”, etc. but not “cord” or “nord”

grep [a-zA-Z]ord sample.txt
6 l7 k5 B% ]$ V- xWill match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
5 h; t  m8 ^6 BWill match “Aord”, “aord”, etc. but not “2ord”, etc.

; ]7 ^& ^( w) P; g重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
2 ]6 q- y8 k& j: D, R
" ~5 j  p0 u' }' Y* Q3 r# e6 cTable B: Regular expression repetition operators
( i, M$ Q0 z# i: k格式说明：
+ B# |+ V9 F( @---------------
4 H9 K5 J( T7 B9 U  J, Y  r操作：
解释：
例子：
结果：
: s1 i4 T, e) E8 ~' s, ^+ g----------------
0 Q5 }' V8 T7 [; x% p9 z' s' f?
) l2 X6 N9 g% X8 o* P: a6 H9 m% AMatch any character one time, if it exists
7 W5 k$ }5 R2 regrep “?erd” sample.txt
' N$ L) T' P! ^( |& AWill match “berd”, “herd”, etc. and “erd”
6 x( g# ]2 S. S! N------------------
* k# p8 A/ ]# O*
  m5 |2 P' D; ]. ]7 a2 c( j" D. TMatch declared element multiple times, if it exists
egrep “n.*rd” sample.txt
2 {. z2 `) S$ cWill match “nerd”, “nrd”, “neard”, etc.
-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
. d8 Y. \2 S! p0 ^* j% [1 E4 W; }Will match “nerd”, “nnerd”, etc., but not “erd”
& W* p  j& ]- E) G- y/ `! l+ o--------------------
{n}
/ m6 v1 W% o( f% r  r; QMatch declared element exactly n times
% E( \5 O# w! I7 i9 @0 {egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
. K+ V% m% |+ t, }7 Z1 Q' ]/ s------------------------
{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
7 y8 a6 P1 u: M# O- eWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
9 C3 Z2 s) ~, A9 pMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
2 D& V0 S0 T! h2 D6 \/ TWill match “nerd” and “neerd”

- g) T% v. r1 x6 X第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

2 S( x. g- q% W7 vs/pattern_to_match/pattern_to_substitute/
7 d# S. ~8 L: o) ?( E

0 `5 l2 A) U" x% \Table C: Regular expression anchors
-------------
# ]* P3 a# c; D: m- q3 c, J操作
解释
, [* V* G$ D% Y: m& j例子
结果
---------------
^
4 w2 Q) n4 \% o( T( s& DMatch at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
$ J7 h; k' k6 K---------------
$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
+ @# `2 S1 T% E6 h8 d  q* y---------------
\<
Match at the beginning of a word
7 p' ]  h3 X8 X1 {% K  \0 fs/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
\>
6 e4 s" q' N$ P7 kMatch at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
" D- P7 R! y2 V! R0 Z, d% }- Z
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
* c2 V9 ~/ `: ?$ z---------------
9 Z. n6 k6 ]. F! Z\b
Match at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
1 M; _" y; R0 H! w4 L1 K\B
- L% l. p) c2 \3 z/ @* q5 QMatch in the middle of a word
- Q+ I* |0 x0 _# vegrep “\Bblah” sample.txt
Matches “sublahper”, etc.
" O1 N# B4 p: q; L
间隔

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

egrep “(n|m)erd” sample.txt
) Y2 i! I$ q# O& x+ Y2 n" ?
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt

( p+ s8 l: l* T当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
( Z. n$ Y- h8 [6 Q2 Z3 d* A, _
第四部分：
$ D% ?7 \/ ~7 E0 J----------------
一些保留字符
1 C6 z+ x2 _! E$ Q! b% v$ e% B  D3 A! _Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
3 t2 ~. T; a4 P; [6 S
" k; _0 w, F% ~! E* S; K5 g0 {^ (carat)
. (period)
! V6 O6 h$ p4 E* }[ (left bracket}
+ X- S$ n8 a9 x9 G* c1 e! m& [$ (dollar sign)
2 c- K8 T' j5 I, P6 k2 }( (left parenthesis)
) (right parenthesis)
| (pipe)
  B: Y" _" g$ {7 k/ u6 E! x- l* (asterisk)
+ d/ ?6 F7 t5 s5 ]6 W# F+ (plus symbol)
4 F' a/ S& a$ l: e0 Z9 w? (question mark)
{ (left curly bracket, or left brace)
\ backslash
) D. {: T2 w  m) x- H' k一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
( P- d0 {$ ]7 n! k+ _- A, z
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
. ?2 s# V& r* u0 X7 K
# g- `. L( [; P: J你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
3 r9 o; a+ d! f+ v( R6 ?. X7 k3 p
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

/ h* ?# n5 u2 C! G5 ]# D+ _& S另外一篇文章
+ W6 R; U  }: Z* k, X5 `----------------------------------------
3 I6 R% Z; f) G8 i正则表达式和Java编程语言
-----------------------------------------
类和方法
+ a* M- u; g( c' Z- y9 @
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
3 `) ?( v. q* i/ y1 T7 f* g
* f* V0 u9 T0 v# ZPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
8 z' ]6 @# _/ j. n1 m. B. @/ @
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
$ C0 Y- O' ~4 s
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
+ i! q& x7 S' H  _7 Q3 v$ i
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
, Q" c& ^1 }+ V! [# k
/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

public class Splitter {
+ k3 y* R- n( D' Ypublic static void main(String[] args) throws Exception {
0 ~9 k; F$ G6 I8 d' ~! w% C, B// Create a pattern to match breaks
; u$ D1 a& @; E% l$ _Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
/ D) q1 m/ r# y' x% ?: J$ YString[] result =
   p.split("one,two, three four , five");
; w" j$ d2 P: f5 F+ {- _for (int i=0; iSystem.out.println(result);
}
}

. ]9 L0 l3 ^. x" ?$ Q* xMatcher类

Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

; [3 j/ d( F) U4 ematches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
0 `& V1 K( l: r/ b8 B' U! tfind方法将扫描输入序列，寻找下一个与模式匹配的地方。
) @8 ^2 S9 k. W- B' v+ O- _
, p9 O3 y5 Z7 R. |2 c# S; E$ c% C) Y这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

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

3 E1 e% D# p* `1 Y例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
$ K; u' A* K: }, R  @5 b8 F
CharSequence接口
0 }: _; \& ]% f3 d  F2 o0 M
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
/ J. n, V4 T  l3 u
5 l* e8 i7 _8 X+ W7 H5 gRegex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换
3 q8 R0 C3 ?. [+ u" |; v
/*
3 M/ l7 G: w& r# m% P- r4 X* z* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
2 k4 Y6 _8 l  a7 O6 N6 K/ ^% N*/
import java.util.regex.*;
# W  s& ?* s( s& T5 s
7 {) \/ {/ Z3 m7 s7 y6 ~public class Replacement {
' p; L- k. s9 C2 S7 ^public static void main(String[] args)
4 J+ `9 G9 |& u. g" ?       throws Exception {
0 J7 L- [/ B5 `2 j( [// Create a pattern to match cat
- m1 C9 q9 U# ^Pattern p = Pattern.compile("cat");
" U; Y5 Z5 p. b8 Q/ ?. F; E) U, i/ `// Create a matcher with an input string
" b/ `' x8 o2 y8 d- `# `" o& ]Matcher m = p.matcher("one cat," +
     " two cats in the yard");
+ E) A4 t, b& ^8 }' wStringBuffer sb = new StringBuffer();
( `$ q6 J) j7 }& A  J4 Jboolean result = m.find();
, h& s5 B# u* V- R. F" V// Loop through and create a new String
// with the replacements
while(result) {
6 k8 d( j' r5 [+ Y9 `  y; fm.appendReplacement(sb, "dog");
* s, l% o0 G! ]# ~: Z$ |: x+ y- kresult = m.find();
}
// Add the last segment of input to
// the new String
m.appendTail(sb);
: u& x) g  S% h. dSystem.out.println(sb.toString());
}
}

0 p  X$ r; c3 b  n! ~电子邮件确认

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

# E  @" _2 u; T: V$ d0 p1 K  o/*
* Checks for invalid characters
$ y5 q* U0 D( \# ~* in email addresses
*/
5 s% J# n9 j' e% O' R" f* wpublic class EmailValidation {
. I1 }, V2 j6 P  G" v) I' ~public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
# h8 b. J3 l( t, `# S9 m+ B3 I//Checks for email addresses starting with
2 R$ i# E; H# }8 t& k1 O8 W8 E//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
0 A4 F& ^; D8 D' O" ?, r. C8 fif (m.find())
; ]& W4 y$ f/ q! v7 MSystem.err.println("Email addresses don't start" +
3 i' o' d( Z' @7 W* A% G! L         " 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);
! A8 D4 Z2 J" ?$ ~$ p( Xif (m.find()) {
System.out.println("Email addresses don't start" +
% k6 T$ X4 v1 y- ^$ _) N. s5 @, F   " with \"www.\", only web pages do.");
  E* y" N1 K8 {5 }}
1 C) X" Z6 R# lp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

$ n) w# x; v; i5 xwhile(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
- N0 L" f. X: c# M5 p$ d* f* |! ~% wresult = m.find();
}

// Add the last segment of input to the new String
2 Q7 X" M: w; A1 G3 B# F% am.appendTail(sb);
" C/ z( N  o' F2 u
input = sb.toString();

if (deletedIllegalChars) {
: H; q5 P2 |6 Y% V+ p& SSystem.out.println("It contained incorrect characters" +
5 J* k2 G& e& P3 j9 @" _       " , such as spaces or commas.");
+ O( M/ O7 B! l8 M+ E}
4 r; r4 s* d* s}
}

% n. R( b! x6 Z/ F# j从文件中删除控制字符

/* This class removes control characters from a named
5 {* p* d- w3 B' |) W2 V* file.
*/
import java.util.regex.*;
import java.io.*;

5 s3 N/ [9 x- }2 y& b$ i# s: Qpublic class Control {
: V0 D, v: A$ R& ~: Upublic static void main(String[] args)
/ G( X  @' C1 H, d6 P           throws Exception {
3 S; m, `: X4 \8 ]- `  S           
//Create a file object with the file name
: g. C4 j* T7 T4 C$ Q; b7 |6 J//in the argument:
7 ~4 ~( B0 h; j- M) ]File fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
$ @% C* X. l! h1 A/ o' t/ GFileInputStream fis =
       new FileInputStream(fin);
: X/ y% L( B$ o/ U" oFileOutputStream fos =
       new FileOutputStream(fout);
8 x# e% s& _0 I
! X6 m% M3 e6 |" gBufferedReader in = new BufferedReader(
* A# X/ \" }$ i/ N& \' N2 t" a     new InputStreamReader(fis));
8 |  U1 O7 ^: K  FBufferedWriter out = new BufferedWriter(
# S5 W& r% R; S7 R) K: S     new OutputStreamWriter(fos));
" u9 {$ O6 Y! ]* Z6 Q
// The pattern matches control characters
, f0 i) M) N& L( n  C3 j. F. w2 [' SPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
9 j- L2 `: ]# D1 q! _* Jwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
0 F' o* ?8 P' Q8 y0 Y$ m: T! ~//Replaces control characters with an empty
8 \+ f$ V/ |7 D0 E# j7 I+ u//string.
  r: F. Q4 u9 ~3 H; P8 s& [3 mString result = m.replaceAll("");
( }9 W: S/ z/ x" j3 ^9 lout.write(result);
out.newLine();
}
1 b- H4 K& G8 R* Y  ?0 }in.close();
out.close();
" k2 k9 }$ u/ ]  l9 p}
}
- H/ F% S/ x  A' _5 ]/ I  A
5 d& D4 E. X* g' v3 Y  e6 w文件查找
6 C9 B5 R, k0 j
/*
; V  d. ?; J! C* Prints out the comments found in a .java file.
*/
* M7 V: k& t0 a  E: |9 P6 Pimport java.util.regex.*;
; d0 A) }/ v+ T) Eimport java.io.*;
/ s" ?$ ]# s5 J( ]2 S* k! x+ uimport java.nio.*;
5 _( {( T6 L3 N1 u1 B9 A0 h1 j% |! Himport java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
) p$ b) }) W3 ]$ O7 k, r/ gPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

7 E% R8 J1 ?9 _// Get a Channel for the source file
File f = new File("Replacement.java");
' K) {: ]& g6 A9 u& k: L; iFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
( F/ f  l& q& ^$ ?
3 N& _% I- u% t* d5 x. g6 s  [// Get a CharBuffer from the source file
ByteBuffer bb =
9 V8 w2 ]/ x: a- ifc.map(FileChannel.MAP_RO, 0, (int)fc.size());
* D$ V9 n0 g: @5 e' q1 C; i! H+ y0 _Charset cs = Charset.forName("8859_1");
% P* W* m# ]1 a+ l& ~& ?CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

% u) g8 u& ^' `/ O9 p// Run some matches
Matcher m = p.matcher(cb);
* g1 ~  y8 C+ }" G0 Vwhile (m.find())
: \) {; j1 Y$ C/ s& G# _# ]8 cSystem.out.println("Found comment: "+m.group());
" r9 S) t5 w  A+ ^}
}
$ X0 p0 h0 Q# R( U; Z
& \3 h, @- J; D* W结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
3 w8 b. o# Y9 W# n
6 Q" x2 e5 f5 A4 }( h$ w3 KJDK1.4之正規表示式
% D! D6 y: c. \. m, S! owritten by william chen(06/19/2002)

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

- W/ s% ]/ q) ^  B' u! m什麼是正規表示式呢(Reqular Expressions)

就是針對檔案、字串，透過一種很特別的表示式來作search與replace

, i: n) r  L" Q* j7 k! z因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
+ K9 n6 h. e8 P
0 P8 y/ p  e( Z. M2 A所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

* W+ f! N7 T4 X' o2 K若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
+ V  ?8 m! U8 X+ I' d% o- Q/ J2 E
"." 代表任何字元

, |. J- \  G0 w; \$ l正規式 原字串 符合之字串
. ab a
.. abc ab
# r0 A! m  J9 u$ W
"+" 代表一個或以個以上的字元
4 Z/ @) ]* a5 g, t"*" 代表零個或是零個以上的字元
" R8 j' i3 ^' q. E( G" g% q
/ a, P# E3 E, z) K正規式 原字串 符合之字串
+ ab ab
* abc abc
) c- |1 l; h" Y7 i) D
- h1 t3 p; }8 |0 v' ?$ T"( )"群組
5 V8 }8 t! d% S2 G- a
' {3 S; z! @% U, C正規式 原字串 符合之字串
$ ~1 K# c1 b1 Z/ ?- i$ k(ab)* aabab abab

. d4 T  D' ~$ J8 O- w5 N7 t字元類

; [- V: d0 \/ t& d4 l  V正規式 原字串 符合之字串
4 J; N8 h1 P( i. t$ M. a  s) H  `[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
- D  I7 h% g0 T. C# v[a-d]* abcdefgh abab
- b" @  ~/ ?4 W9 H

4 q5 @0 J- U% `8 S簡式
+ B& ~* P+ c% g6 o! a
& ~$ X, z! g/ y. o/ S! ?9 q\d 等於 [0-9] 數字
8 n+ j2 j* \7 Z3 _6 o0 D. Z\D 等於 [^0-9] 非數字
0 J) v7 J. q* k\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
" W* o" A  z0 h, E' x5 S$ l
每一行的開頭或結尾

^ 表示每行的開頭
$ 表示每行的結尾
* a4 r! z# D$ Y7 s
--------------------------------------------------------------------------------
$ w" H( P4 E2 b# H) _6 J! m. H
正規表示式 java.util.regex 相關的類別
0 T6 h" `5 v9 v: p$ `- B& J3 |
, H" x$ i( S7 E* PPattern—正規表示式的類別
Matcher—經過正規化的結果
& [" b5 c2 w2 f) r7 GPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
# g6 t/ u2 n. B4 ~8 \, w
4 \8 H* J+ P5 C9 s範例1: 將字串中所有符合"<"的字元取代成"lt;"
; k9 a2 J$ M' r( S/ N+ f
- D+ w2 L1 y5 q5 r4 B. Gimport java.io.*;
import java.util.regex.*;
( f; C3 [$ l  ]1 ]# X, z5 ]+ i0 T, `/**
) [5 u" G8 F* t, |4 ]4 G- B* 將字串中所有符合"<"的字元取代成"lt;"
*/
- K7 k) \( r* I4 B* J$ O, M  N- b$ lpublic static void replace01(){
// BufferedReader lets us read line-by-line
( [1 q6 `0 f3 f: kReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
5 T! H5 H0 Q1 _4 L- v7 @String line = br.readLine();
$ ]1 r/ C- d* k* W- n' ?// Null line means input is exhausted
if (line==null)
2 A# `. {% }; Hbreak;
Matcher a = pattern.matcher(line);
6 d' B& p5 ]2 T. u  N, W: U7 O0 Gwhile(a.find()){
7 y2 `. `+ ^& `9 ~( `/ hSystem.out.println("搜尋到的字元是" + a.group());
+ w" E3 S3 D- C  p' N}
% e% j3 z8 o' Y4 H) hSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
# O3 L3 F' d* C" C}catch(Exception ex){ex.printStackTrace();};
}

範例2:
9 T1 U/ j+ a4 S  R2 Y
5 m+ `4 `+ H- `: U3 Himport java.io.*;
import java.util.regex.*;
/**
* 類似StringTokenizer的功能
4 x( C/ J* |' y2 l- G) l9 i, H3 F* 將字串以","分隔然後比對哪個token最長
*/
4 s9 g- ]$ w" B+ A( `- a4 `( E3 ypublic static void search01(){
// BufferedReader lets us read line-by-line
5 J# `0 s1 H) ]( @0 H% t, G/ A- [6 RReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
# W8 Q* Y% g8 m: f$ dwhile (true) {
, K" `# L% ]# ~2 L! t) E% I* vString line = br.readLine();
% \, z/ ?0 D, Q; P0 AString words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
! }4 W4 V+ n% t! i! Jbreak;
// -1 means we haven't found a word yet
" R6 k! @; B9 q6 E& ~+ V% |int longest=-1;
1 z3 ]. ]) S1 O1 b4 h8 Z2 [& qint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
' b0 c/ q4 e# t' ]longest = i;
5 @9 _2 d$ {5 ^9 `  f( d7 clongestLength = words.length();
& M% R0 h, Z# T}
}
System.out.println( "長度最長為:" + words[longest] );
' V$ L0 b4 }7 ~+ L3 e6 r- Q, @}
}catch(Exception ex){ex.printStackTrace();};
}

5 M  p8 i- i- v6 _( j--------------------------------------------------------------------------------

其他的正規語法
4 y( b: q: Y! p. W! n: P0 m' A
/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水