关于正则表达式---ZT

Longe

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

支持多种平台


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

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

0 r. u4 z* x- y. }许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
" j/ Q' Z0 |2 D6 F7 t
. i, f4 l5 m0 }6 Y' z: Y. v4 {" ?比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
2 C7 V: J7 r  G' l
0 C4 F0 B/ Y2 p+ }6 _正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

0 b+ ~0 W$ ~* X6 g第二部分：
6 x1 M( i5 ^- \- O  b2 c----------------------
3 Z. ]% u$ `% x- O6 Z  D6 u9 N字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

每一个表达式都包含需要查找的指令，如表A所示。
/ Q& @5 [. x, m8 D
2 a! x$ i& y' S; [7 fTable A: Character-matching regular expressions
3 V/ C2 Q- Y2 i% i格式说明：
---------------
操作：
3 ^8 s- c$ Y- w3 u8 l解释：
例子：
5 n( [$ ]6 }! y9 E. ~结果：
----------------
.
Match any one character
grep .ord sample.txt
; V8 @( _+ R$ h- H; H3 [Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
7 ?8 O/ c4 U% z% z6 K, dMatch any one character listed between the brackets
2 }' P- R/ I7 q6 ggrep [cng]ord sample.txt
5 ]- x/ k- y. [/ m. {3 F- wWill match only “cord”, “nord”, and “gord”
---------------------
: M+ W5 r! j" H[^ ]
. ]+ l, G0 L, j5 M2 pMatch any one character not listed between the brackets

grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

% d/ M' b% t6 P& Sgrep [a-zA-Z]ord sample.txt
3 h4 s5 D' I  d) f" v: l& FWill match “aord”, “bord”, “Aord”, “Bord”, etc.
0 i- B8 S4 I, |* q
grep [^0-9]ord sample.txt
2 u$ [2 t. }6 z' S# s/ Y. kWill match “Aord”, “aord”, etc. but not “2ord”, etc.

) O: A, ?; J  \" j, M$ g/ r& F重复操作符
; ]+ i) J, n5 o4 `/ [重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
- L/ `1 l) }- }% b- a格式说明：
---------------
  H9 y/ Q4 @' i* |& x操作：
* O5 e+ w/ \, p6 ~- T$ O& n! u解释：
例子：
结果：
----------------
?
Match any character one time, if it exists
9 L8 F5 D; B) B6 S# Fegrep “?erd” sample.txt
) V8 w, ]8 _4 I( E  |Will match “berd”, “herd”, etc. and “erd”
: f9 I' v! }: O7 F+ i------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
6 V9 g9 _$ L( ?: S% R/ ZWill match “nerd”, “nrd”, “neard”, etc.
# m" o: S9 U& O% q8 S- i  Z7 i-------------------
+
Match declared element one or more times
, C" \. |0 g( H; Jegrep “[n]+erd” sample.txt
  x% E0 S) G9 \( R' }Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
( y0 D& O/ K$ S/ V* E% nMatch declared element exactly n times
* f3 M) G* T5 f( Segrep “[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”
2 }$ s0 j" P* ~$ ^------------------------
{n,N}
) @3 A. a* r) NMatch declared element at least n times, but not more than N times
; v) _# t1 \" N7 G! r; R; u1 gegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”
5 K/ V6 I: O5 q9 s* \
第三部分：
----------------
锚
! F7 }/ x: x% Z0 g锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
/ L+ ^% w/ T# A
s/pattern_to_match/pattern_to_substitute/

2 i& `; ]* ?1 _1 g
Table C: Regular expression anchors
6 j7 ?* V) E5 p: I( o-------------
操作
- q+ k7 s/ B# `( U1 q解释
例子
结果
---------------
( b1 O) Q7 ^! T# H5 a^
+ l% d0 R5 \/ _/ KMatch 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/
6 F/ e+ T8 y/ C. `1 G9 h. UInserts “ blah” at the end of the line
& G9 m& l! A3 k---------------
* H% c0 O9 Y7 K9 A& G$ B\<
Match at the beginning of a word
. C" [6 O9 x! C; Js/\Inserts “blah” at the beginning of the word
- R& P/ ]+ `9 n) V( j
egrep “\Matches “blahfield”, etc.
1 H3 b  A: L. x3 v$ Y------------------
; T2 y; C2 k. @! }# E# _0 ~8 V\>
Match at the end of a word
- F+ R7 C: d: k4 T% Os/\>/blah/
5 b" L% D3 T4 B+ tInserts “blah” at the end of the word
% w0 x6 R# q% x0 d* d
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
2 J+ ^0 t1 Z7 C- ^- v3 K\b
Match at the beginning or end of a word
& K4 r, E6 |/ R& j% w  }egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
+ I2 c* w$ }* }\B
$ O5 Q4 w* u6 k1 q* J3 _5 ?Match in the middle of a word
egrep “\Bblah” sample.txt
( H* z  N) K* M: cMatches “sublahper”, etc.
/ r2 ]- d$ q; k8 R: _, [- w9 o
& Z& z" M; [# T& b间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
; I  E# R/ H) W; V; Z
; [2 F" f* L* R5 Begrep “(n|m)erd” sample.txt

间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
2 p0 g' T6 Z* M
egrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
' {  C6 _1 n  ]& z; H( G7 W; ^( z1 M' V
: r* P5 d+ [, D+ b3 }# u7 r: N第四部分：
9 \5 G. Z+ I3 ^. K& [: U- U- B----------------
一些保留字符
4 b! O( u4 N' H1 @7 ORes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
, ?- I4 d  n9 X
1 z6 L+ M* M5 L% a^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
8 _+ H# k: s( l% @" M4 [( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
9 Z- I  ?8 r4 d  K* X$ N? (question mark)
{ (left curly bracket, or left brace)
\ backslash
4 B! i9 E* ^' K9 K# U1 b/ i一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
- a  l" ^' k8 `' c* h. ~& @
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
9 ]) r& L& i0 B% {" U% a4 Z
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
& v1 D- }$ O, @# y* `1 S- t, P
- x% L% G! T0 I- l6 }总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
9 j7 J: t0 ^! E- x! H5 ^
0 X7 `. w: g- ?7 _7 Z, P另外一篇文章
----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法
( W1 n8 w( y- F# j! F
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类

+ ]9 X: V4 ?/ P1 C  E2 {. P/ I; DPattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

: w: c8 o( Q+ Z$ h% ]: l! X用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
& |, [) e9 X+ a% o0 r! z$ E
, t0 ~7 o  c9 a; j& i2 S用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
& E( J6 {* }7 U$ {2 L' L4 W
% c4 E& y% |7 Fsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
8 z% v  ]8 H- Q/ p! F1 ~- ?9 Q* 用split对以逗号和/或空格分隔的输入字符串进行切分。
# u: g5 b8 X  }5 G& _! C2 r" P*/
+ M/ N& g4 a# a1 {% F) z& ximport java.util.regex.*;
7 J/ C: H  m7 W" i- a* ^
- O1 t4 E0 s2 bpublic 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
( n8 G: y0 p1 j1 x7 B3 a; qString[] result =
+ f+ W; T1 k" f* S* F   p.split("one,two, three four , five");
8 @+ K4 Z; {( C8 n! Bfor (int i=0; iSystem.out.println(result);
}
}
- Y1 M4 l8 K+ J. d( z) z" h
Matcher类
( [* b, y! T2 G6 \5 S( {
# g1 `: F, S' _$ g5 N; lMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

' F% w- A& D; S9 z, r6 v8 `通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
4 d2 a! S) [8 q) a0 YlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
" F& Y! {. ?0 m% \) Nfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

2 A( |* x# s0 W0 s$ ?2 c/ h4 Y- Z这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

6 R( w8 a: X/ d& v0 t3 J/ Y7 {这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

' Z$ h  `! G* [) [# @8 D: J- e& XappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

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

' e- j* [+ Q. k# Q5 PCharSequence接口
5 _5 T& X1 |$ N- F* W8 j% B5 ^2 U
CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

9 s2 s6 S" L  K5 yRegex情景范例
! t* r/ k% q" I# Z1 w) T4 C6 o# o
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
: q( _# G" I% m
  k6 j, m- s  ]! m7 c0 w简单的单词替换

+ t# n$ R5 d: d3 T/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
$ D: y* e) |/ Z) ^- C& v' O& c# Bimport java.util.regex.*;
2 ?: C: W4 O$ k5 i
public class Replacement {
# p1 N" m8 Z3 }public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
% L' x8 ~* ]2 Z( o" KPattern p = Pattern.compile("cat");
// Create a matcher with an input string
8 h- p0 T  o. M" {4 H: F# {Matcher m = p.matcher("one cat," +
' n0 ~! p3 U, A3 C& }     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
4 G+ A, U2 z- ?4 x2 O: P// with the replacements
" e. G% M& m* dwhile(result) {
- J1 E" Y* {" G& L! j- H: g& J7 jm.appendReplacement(sb, "dog");
result = m.find();
) Y0 ^& P3 ]0 l3 g/ _% V}
// Add the last segment of input to
) Q$ a* l$ M3 k) P% ^. Y// the new String
m.appendTail(sb);
; m0 P% {' B, z" O* T9 jSystem.out.println(sb.toString());
5 M2 |  q, G0 P7 y7 Y  a9 m! A}
}
& c! V) ]4 g- \5 w2 x, P
电子邮件确认

+ y# i" q1 Q4 w$ n3 U. z) f+ D以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
; x3 G  N1 {3 f8 c3 A/ a
3 s4 t! o0 e! ~+ D! k  ^8 N/ U  F/*
* Checks for invalid characters
7 ?  j1 y( [0 u3 b; ~; i  X& H& X  D* in email addresses
*/
public class EmailValidation {
0 y8 A$ ]& T: k: H; _' W; }public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
/ o4 z/ V* [; T$ e- d//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
7 A% x$ i! X0 N  n5 R! FPattern p = Pattern.compile("^\\.|^\\@");
5 N# V/ D3 D0 l0 MMatcher m = p.matcher(input);
if (m.find())
2 O8 v! u5 q; D  z# {0 J7 y8 wSystem.err.println("Email addresses don't start" +
4 M0 a: Z# D- S5 M: B) R( u5 H9 c# s! y8 S         " with dots or @ signs.");
//Checks for email addresses that start with
4 R- b( j2 M1 Y8 c3 N//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
8 k- E; |- I3 _2 X* F0 b% vm = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
0 W0 n7 F0 M, z. x8 Dp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
. }. U" A) N! ldeletedIllegalChars = true;
m.appendReplacement(sb, "");
1 ~9 x( ^& E1 X& w* y2 d2 i  J/ ~, c2 ~result = m.find();
6 k" W% N' a8 k; P  f6 ~}
! E& H2 l- s4 F$ ^* `; J
// Add the last segment of input to the new String
2 o2 Y! N9 `. ]0 B; W0 um.appendTail(sb);

input = sb.toString();
. ?- }3 M; D7 ~% ~% y% R
( s4 k. U9 F9 Tif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
}

& Y' j, F3 V! ]从文件中删除控制字符

9 H) q9 ]( y) L/* This class removes control characters from a named
* file.
*/
7 t1 }) U! z2 ]' r% H7 {0 qimport java.util.regex.*;
import java.io.*;

' r* F- K6 s0 `; [public class Control {
  ]! h# I) u- e6 l. F1 @" @6 M2 Jpublic static void main(String[] args)
           throws Exception {
* \! t5 }# b# ^& G/ R3 |& f7 v0 t           
, }4 h8 ~9 C0 M" b1 B& k2 y//Create a file object with the file name
8 Z( T5 H5 h  ]& @3 \* Q. C- r//in the argument:
( f$ |  N- P% r, u" FFile fin = new File("fileName1");
9 k% I2 x3 @) Q( kFile fout = new File("fileName2");
: d. |% [, O2 S//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
4 f1 u1 O0 e& o  pFileOutputStream fos =
       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
; F! G( E, x5 ]8 ~BufferedWriter out = new BufferedWriter(
+ D1 l) g6 t$ f6 h4 C     new OutputStreamWriter(fos));

// The pattern matches control characters
' i& C/ y& n/ E3 o. hPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
* i# d% Q" l) F! [& S& K$ S6 PString aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
  u- f# y; g. Zout.newLine();
}
  O, \( m" [; s. e* a0 ~% `0 r* vin.close();
( q* O1 r9 x- S( i; F& N6 eout.close();
}
}
1 j4 V$ t8 Q# }8 Q
文件查找

6 d+ z* R7 C. `5 `% d9 ]/*
$ q4 ^) x& p5 R- F7 \0 C* Prints out the comments found in a .java file.
*/
% ?$ U, Y: w" D* B. t- s: K3 e7 J& [import java.util.regex.*;
import java.io.*;
5 ~4 W& G6 i$ g- B5 r4 Gimport java.nio.*;
8 e6 a' ]+ G& z0 t- v& }6 L. h% nimport java.nio.charset.*;
4 C1 q" T% ]% C3 @7 J  ~# s; G# a& B- Timport java.nio.channels.*;
: W; ?/ m' g$ y5 f6 H  W$ M8 C
public class CharBufferExample {
  m' Y5 ?0 ~$ P+ R& y6 ?" Y# ?1 ~public static void main(String[] args) throws Exception {
// Create a pattern to match comments
) u9 l" \# ]: b1 M, S. R3 J' cPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
3 O5 w/ \( h. l4 SFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
) |. Q5 P* ]. ^FileChannel fc = fis.getChannel();
, x7 i& h, H/ O, q. A; P4 i. ^0 b  o  h
// Get a CharBuffer from the source file
ByteBuffer bb =
7 l9 X% ^" P; f$ }( C# i, H3 d5 ffc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
  D% L  A% c0 R! g3 C% NCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
# o4 B* W/ t. X+ x0 Q9 g% ^* a
// Run some matches
1 H$ @3 Q: L3 `# X) [- eMatcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
0 P/ A3 o6 R" N}
}

结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
, k; X: l6 I" X0 N! Z, Y
& ]6 A  Z0 |" xJDK1.4之正規表示式
2 o" M' [. ]2 O* m& s9 ]! Rwritten by william chen(06/19/2002)
: q( P3 Q! L; N! ~
# H! k5 Z$ V7 w1 p8 P& y8 T4 y--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)

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

1 h/ i; Y/ P; j1 j因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
& Z6 ?  f- B) Y; ^5 c3 Q
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
; [# V( O" g% d9 L* P
/ o. a% O3 d6 Z& N9 N. w  N剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

3 k/ Z/ C! `* E# ^( M"." 代表任何字元

正規式 原字串 符合之字串
* `/ ~9 q0 ]6 ^9 W7 f% |. |. ab a
.. abc ab
8 z5 I! u& |4 f4 {/ E
1 \$ M( x6 `4 C"+" 代表一個或以個以上的字元
! z% B. ^1 C4 a& R  b7 k6 ~"*" 代表零個或是零個以上的字元
) k, _$ r0 |: [  T" _( C8 N, h* t
. d- K$ m$ N0 p' o正規式 原字串 符合之字串
+ ab ab
  Y: E! _" ]/ d; M0 ?* abc abc

"( )"群組
) o2 m8 q4 V6 q+ @* L  \
( v3 K9 O) G" p$ C* Y正規式 原字串 符合之字串
4 \7 O" X& [" @(ab)* aabab abab
, ^  g& ~# }: U' o
* n, N. X6 e4 y5 y! i$ P+ x字元類
* p* w* ~2 G) v
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
' j. L" `! ~( Q: M# T1 g[^a-d]* abe0 e0
[a-d]* abcdefgh abab
/ X% H9 c, _) g# `$ G& T
) g1 u! R2 q5 M7 X; x
( `# I5 Z0 ~; b. e3 w$ m; m簡式

  `6 K. J" E* [* m; B& {1 B\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
& V) _" g7 E# {& z! f# \\S 等於 [^ \t\n\x0B\f\r] 非空白字元
1 Q1 V# a) t! q( N7 S\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

^ 表示每行的開頭
7 X8 P# \$ H3 S% M8 L$ 表示每行的結尾
3 F2 z- u+ M- T! _2 r# x
% u$ j0 E1 r5 a( ]. S--------------------------------------------------------------------------------
. x* ?8 V2 s7 }2 T: X
+ H6 I, U4 O- f, w正規表示式 java.util.regex 相關的類別
% X6 H# p- u6 r  e# {4 N4 I* G! A
Pattern—正規表示式的類別
& D+ n5 z, h: ~' OMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
& k- h8 D) `1 V6 V+ D1 b3 N% O
' q4 {7 Z4 i! [, I% U9 A  }" h範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
- W3 b3 @& w7 @import java.util.regex.*;
9 B2 M. v: A7 F6 s( [9 Y2 A/**
* 將字串中所有符合"<"的字元取代成"lt;"
9 b& r( X: \7 J/ G3 ~3 {! k*/
public static void replace01(){
8 O% f) N6 M- d// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
2 O( q0 Q2 S& c7 _$ f0 ltry{
while (true) {
" X2 K+ n/ D2 F  uString line = br.readLine();
/ u6 ~1 u/ o7 D8 b0 W// Null line means input is exhausted
if (line==null)
break;
' p1 n) P0 T* N! n6 R; ^. NMatcher a = pattern.matcher(line);
% H. `5 @4 l4 a  T4 H7 zwhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
# h; J2 I4 ^) @! k8 o1 J9 S1 x" ]8 ASystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
0 _3 c& v: Y6 h0 ?}catch(Exception ex){ex.printStackTrace();};
}
9 G8 l" l9 |  A: s( Z
範例2:
$ Y4 H; _2 l5 y, m5 B+ m) H
. Y( j/ D" b9 f3 A& B. B/ W. mimport java.io.*;
: k  P( S5 ~. G: F* c* rimport java.util.regex.*;
9 Z+ v& Y" E! G! e3 i/**
- Q  M( ~4 c2 S2 {6 a* 類似StringTokenizer的功能
6 B/ o3 R0 B2 `' g* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
// BufferedReader lets us read line-by-line
+ S) B! A+ [/ \( R9 y. kReader r = new InputStreamReader( System.in );
: }, h2 R" K+ Q6 fBufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
: F7 e$ k; N; o) _while (true) {
" B/ O: ~% K1 \/ Y  VString line = br.readLine();
& c3 s/ ~0 d8 _! a% I/ C; r& z$ }String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
# q; }# U  @; p4 y// -1 means we haven't found a word yet
( n7 i7 g7 j# t" qint longest=-1;
/ I; Y. O: X- @- ~int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
0 l0 s2 d# A8 y3 G3 W' D* S5 h2 bif (words.length() > longestLength) {
9 ~' }" Z# Z* R& i& j& J+ c5 Y/ Slongest = i;
5 B3 ]/ @/ a( o/ f+ H( E! ZlongestLength = words.length();
}
}
System.out.println( "長度最長為:" + words[longest] );
- }3 s1 n2 }4 B* }5 v1 `. n2 W9 @}
" H( F' s! C$ e}catch(Exception ex){ex.printStackTrace();};
2 V: ~2 e0 B8 y5 W2 p% U+ Q}

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

% z2 ~" f- [7 E# L, C5 t其他的正規語法
) a4 Q* M! N) a# b6 j
  x( w  r& }3 C/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水