关于正则表达式---ZT

Longe

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

; ^1 Z1 J) |6 O支持多种平台

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

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

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

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

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

第二部分：
----------------------
字符匹配
! g$ q( M8 n5 v, d9 |
正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
# f# ^6 a1 ]% a
! |. y7 l- D1 K: t  e每一个表达式都包含需要查找的指令，如表A所示。

# q* T3 U  S" V$ X9 t1 `) mTable A: Character-matching regular expressions
* \5 l8 x, `# g8 Z1 z  T' j& A格式说明：
---------------
( y$ T7 O8 }9 j5 A& J  J: E操作：
解释：
例子：
结果：
  x% B) a4 |+ @) ~6 ^+ M----------------
% ]2 u7 s. }7 V9 X+ n.
Match any one character
8 r  T/ E4 L% ^/ n" T7 L# ggrep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
: ]. }6 M* X* h0 F; Q: C8 I- c% W-----------------
1 [: W# f) F) H; n( J[ ]
$ S$ M7 b2 ]6 f; p( c3 w" uMatch any one character listed between the brackets
& l2 e/ ^' ]/ Y! v  S& ?$ ugrep [cng]ord sample.txt
( b7 O) v7 I, H$ EWill match only “cord”, “nord”, and “gord”
---------------------
$ L5 |! v+ y; Y' K# V3 c& ?[^ ]
3 N2 U7 k; q7 R( K% `# JMatch any one character not listed between the brackets
& m% N8 f1 M! e( n4 j+ k
grep [^cn]ord sample.txt
" ?6 N! _  q# M' `7 [) D7 z/ MWill match “lord”, “2ord”, etc. but not “cord” or “nord”

) v" ]5 Q+ d$ Z2 |" q, f, }# O1 Dgrep [a-zA-Z]ord sample.txt
9 v9 l8 ~. I- |" t+ q/ ?, oWill match “aord”, “bord”, “Aord”, “Bord”, etc.
4 L0 j% B  R& K( `# {, a( B
1 p' X0 [. y3 u8 `4 N8 R/ Kgrep [^0-9]ord sample.txt
0 @) i1 @8 S9 V3 Y! d2 ?4 ]- ^' `Will match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
# r% o9 y, t( X3 e重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
$ i, y) N9 Q  R6 D4 O---------------
操作：
解释：
# X1 i- d+ a6 g例子：
结果：
----------------
?
7 s2 {% z, P# O. GMatch any character one time, if it exists
egrep “?erd” sample.txt
) b2 d6 F4 z% t+ sWill match “berd”, “herd”, etc. and “erd”
8 B" d, C' j) x3 N# }4 u------------------
& ~, g+ o: @5 I# x7 j8 K. N3 V, C*
5 y, c/ p; A6 m& ~Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
; K( C2 e3 O( r- F! B' K, T0 gWill match “nerd”, “nrd”, “neard”, etc.
3 u% c$ C& M" T; L9 g/ w  {-------------------
+
Match declared element one or more times
& z3 t- M+ K1 ~egrep “[n]+erd” sample.txt
3 H# ~1 u  i% q) PWill match “nerd”, “nnerd”, etc., but not “erd”
0 R- o! `/ e  U9 K: F! p% x--------------------
0 j1 k% L6 x1 {. d" o6 p9 ~{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.
/ c" s4 Y% ^8 y) I7 |6 W7 Q. T------------------------
{n,}
" j; j, P( \2 F9 I9 YMatch declared element at least n times
0 @" N5 |7 ~& ^egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
5 `- F) E6 F0 V{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
7 @. E& @* S8 f" [8 YWill match “nerd” and “neerd”

6 @5 B& }; {  B/ o第三部分：
----------------
- R$ c+ x7 C3 }4 r1 H8 |; A% f锚
9 _7 }9 h8 @0 r% [1 J* J# d( v3 u! ]锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
; |# W7 D+ }% q# ?
s/pattern_to_match/pattern_to_substitute/

' r- x& H) X5 |6 q: h
Table C: Regular expression anchors
-------------
操作
解释
  w2 K' k- Z9 Y) ], o2 S例子
( X. b, e0 n$ M3 S, |3 {# p结果
9 C4 ~! G! z8 _* ^5 `+ L---------------
# ?* R% p' q" \% u% c+ T# K^
Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
---------------
+ J6 j. F5 N% K0 d! z/ g- X# ~$
Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
& N4 M+ \3 \( G' V: s4 {, D0 p% [" c---------------
( R( T/ W! t9 m  r1 M  o. T. E\<
# x2 f  t, u3 l3 ]1 R! L7 `Match at the beginning of a word
, m: J+ w* q7 {  Is/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
\>
Match at the end of a word
- @# [1 }! ~" H# ^3 r4 w  Js/\>/blah/
& L' |/ f" ~1 t: }0 TInserts “blah” at the end of the word
# `7 E  i7 H# _$ ~- o/ h2 W
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
* R/ Y1 A% o4 d% _5 A  m---------------
  L/ _3 s1 \8 Z( F6 b% T  K" x\b
" L1 v: [* F, ?4 }4 h2 h% s4 {Match at the beginning or end of a word
egrep “\bblah” sample.txt
) m/ Y" N5 X" p8 G) k4 [Matches “blahcake” and “countblah”
-----------------
1 Q  f8 s4 @+ u% K6 ?\B
Match in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.
) C; n) p9 [+ h9 S' v9 h' s1 e
间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
' _5 O) o- O4 {% S6 ]+ E0 n( `6 A
/ J% P% j( z6 U: y1 Tegrep “(n|m)erd” sample.txt

1 C# p6 ?  R- j6 u# h9 J间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
9 d, n  G+ [5 A+ t  V* s
egrep “[nm]erd” sample.txt
' Z5 N+ P7 u/ r- [% g2 `
3 X2 ]0 }3 e; p- p" m3 D当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
5 _9 `1 ~" x& j----------------
/ P6 a" x3 L) f# w一些保留字符
# F, `5 u5 B- n4 ~1 j+ PRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

, t  C7 b+ ]4 X. m( ~2 P' F^ (carat)
. (period)
: ?7 I4 q& c8 U9 n9 ]' r; C" K( _6 A[ (left bracket}
$ (dollar sign)
( (left parenthesis)
1 R1 k* ~. e: Y: g1 E% n9 m" K) (right parenthesis)
| (pipe)
& J, O2 k: b+ J  m# t* (asterisk)
+ (plus symbol)
? (question mark)
/ c2 L) t6 v/ B  c+ T! s1 l{ (left curly bracket, or left brace)
\ backslash
. ]! j4 Z, W3 O- b8 r6 N% Q一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

  f6 v2 s( w+ q" Keregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
, Q/ Q: s# g  f: I: B/ p
- p, R1 o8 Z  o0 q+ C% c3 I你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
; \7 ?% u: ]( R7 ^! [, N' e在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

9 r; y7 J% a- y8 [另外一篇文章
----------------------------------------
) G. c6 V$ y( c! Z3 {% Q" H正则表达式和Java编程语言
-----------------------------------------
类和方法
6 {, I# s( o, I3 ~! E
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

) Z; S. M& ]) k0 aPattern类

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

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
; S$ D+ p1 V" v9 E, N
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
& w+ B0 S, U. c' _1 {: P! G- o
7 d# F! n1 C' N2 a* o) `split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
  g2 L" @& _7 a8 e
/*
; v$ C/ F2 V- P, R) R2 u* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
9 b, E' b% K( ?8 @import java.util.regex.*;
# n8 u0 h2 h5 V0 O. G" s
public class Splitter {
public static void main(String[] args) throws Exception {
9 S5 W/ m+ S# ^3 A7 C// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
! s, w( n# }) [) w  {// Split input with the pattern
String[] result =
2 H) H7 o: A' J% k   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
! T5 H. l( q" t! d3 I2 Q5 i- l}
}

Matcher类
+ b7 x% G% n, x' i& |: u( P% S" r
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
) R& T- e6 X4 B6 v" n
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
6 [$ K! Y8 b% X% q3 Q1 z' mfind方法将扫描输入序列，寻找下一个与模式匹配的地方。
9 j  y3 z9 g* T2 n. q
. }$ r4 B; d5 L* Y" K- j这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

% l5 F# O# g5 S这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
# k  N7 D! j$ Q' |; {' {2 m& W
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

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

CharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
: `$ X7 I3 t& h! E% x  [) T
# `; Z$ j& ]1 G% {" r3 XRegex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
0 U" e2 y( F- r1 z8 |! ^% ~+ o' ]
简单的单词替换

/*
6 Z4 A6 @5 w3 D! \* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
1 `. y0 ~% u6 H; v' _! y* ?9 Oimport java.util.regex.*;

public class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
& g! X7 X$ z5 i) x4 [3 jPattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
; A2 |5 V+ g) ?( t! n( i$ P, jboolean result = m.find();
// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
& P  X, x1 M  p- Z$ i}
& p. s) z: h  y- p! z' E9 Q// Add the last segment of input to
// the new String
m.appendTail(sb);
& V! j6 t- \$ e$ ?/ q! h% q* JSystem.out.println(sb.toString());
}
: o4 C3 p, h- f}

电子邮件确认
$ m( N$ F6 O& E3 a' c0 q* d
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
3 H( w- d6 p  B! C: o( a
; x( Z" }/ k9 `) b/*
* Checks for invalid characters
* in email addresses
*/
5 G4 ?" ]( U5 [. ]: p6 Npublic class EmailValidation {
public static void main(String[] args)
% T; Z7 r0 }& |; C6 r$ l           throws Exception {
1 p$ z' J+ M6 N- Q, D! j4 J           
String input = "@sun.com";
/ {0 F2 a- ~% w/ w: s% ]//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
2 U' I' A! ]7 @/ |  IPattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
: H3 x& d' \* C. aif (m.find())
8 N3 |' T# F/ W7 i' G: c. A5 dSystem.err.println("Email addresses don't start" +
+ R; E  Y! F$ G6 {5 r4 A         " with dots or @ signs.");
  D  t( t& K! _- r# N% _& y- V//Checks for email addresses that start with
+ R$ g0 O7 m5 q) z//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.");
}
( l6 Y, E. y; \p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
' l/ n" ]$ {7 U7 \- U$ _! Dm = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
* U% X3 S3 K# H$ {$ {3 Z  S6 `  U
% P' Y4 F* d# P) f' y, Z( ^7 ~$ qwhile(result) {
deletedIllegalChars = true;
( }- H9 t4 S  f; ?2 ]0 R5 `& Zm.appendReplacement(sb, "");
9 H+ r# @; X% J* N3 hresult = m.find();
}
7 v% r' U  K+ p, i; v4 _4 P% Z
5 `) M" ]' \- G2 k* J// Add the last segment of input to the new String
m.appendTail(sb);
, H- K7 R4 Y/ L; e3 i
input = sb.toString();
; ^9 [" P. Z* z' D' o
if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
  g1 }# C  Y8 k9 E       " , such as spaces or commas.");
}
1 M1 _: C0 a: O3 i$ ?1 S}
* n) e$ Q0 c, y/ ]8 z* ^) l}
# p* k, m0 Y7 w; C7 a5 G9 L
8 e' B7 Z1 n- K从文件中删除控制字符
5 f0 P5 K& @& o  C4 |8 c/ m
, f% Q# R8 Q  o) M  t, r9 \/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
4 x) m1 n) X  ?2 O% wimport java.io.*;

public class Control {
public static void main(String[] args)
           throws Exception {
+ g$ }' |" u0 T: Q. o, W           
& U* A- U4 N' ?# @& r//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
+ }4 V. r; S) N! F. U7 @File fout = new File("fileName2");
+ t/ f" n$ t$ d$ @) o% j. C! Y/ o//Open and input and output stream
" G7 j* T9 T5 a% K  }; o( [FileInputStream fis =
) z. \, y& |- R  C% P       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
0 Z9 v6 [8 i- h% R; F2 n
BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
- j! M9 T" R5 p     new OutputStreamWriter(fos));
1 l& r# S/ @  Z8 D
// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
! O. _! _' M$ n) OMatcher m = p.matcher("");
2 i! g* }) p+ F6 ?+ {. sString aLine = null;
  o; I  i7 [5 Iwhile((aLine = in.readLine()) != null) {
# v/ O* `+ W6 K2 b. o& Y( Am.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
! A, w$ o  H9 J* p' _) Vout.newLine();
}
6 B. p6 D! G1 }1 v3 n% e* M  J# sin.close();
out.close();
}
}

$ ?+ T* g$ ]/ N4 [- I! X7 ^( _7 e文件查找

/*
  v* o, ]8 [. y& K" h1 p4 F* Prints out the comments found in a .java file.
& G: C% Z7 x0 @- l" y*/
" ]# y7 b8 W8 w/ p8 a# [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
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
& F. f1 M3 a; r, \6 |1 d/ L% KFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
) x( X, s' K1 T% k3 v# e8 \
// Get a CharBuffer from the source file
( q- Z4 B, t, E1 w+ \( v0 A$ bByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
+ e/ q4 h! [0 OCharsetDecoder cd = cs.newDecoder();
$ B& @, I$ [' M( y" K$ a! N" q; dCharBuffer cb = cd.decode(bb);

( k, b1 m( i0 S# d% j// Run some matches
Matcher m = p.matcher(cb);
: m; k0 F2 Z# X/ A8 N) x* l3 [while (m.find())
System.out.println("Found comment: "+m.group());
) ~0 C" R2 b! i# u}
4 V) D& M9 Z" e" p}
: u/ T2 }' j* n5 b3 D+ t- E
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
% ~& W$ c0 K% x' [( ]" l
4 c8 b2 ^" L9 f6 K) r+ w) D9 yJDK1.4之正規表示式
written by william chen(06/19/2002)
' N$ |" S# a$ V- ?! F9 H- h
& T9 o; H. K+ |8 E0 z9 p( Q--------------------------------------------------------------------------------
/ w1 s0 e' l( a/ |
什麼是正規表示式呢(Reqular Expressions)
' Z& E; p* c! o
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
/ w' l' c5 B( l4 ^* j: Q* P/ H
因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式
7 V- D6 i/ R6 b% p( G& c
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

1 R$ v$ c3 v+ g4 b& k0 v7 s: I4 u剛剛列出的一串符號" s/
: x' A3 b/ ~  w2 Q- N4 g7 g3 J0 ]適用於j2sdk1.4的正規語法
3 {. x9 G' _* W
"." 代表任何字元

) I$ h5 s4 g3 S$ x/ Y, r" Y正規式 原字串 符合之字串
. ab a
  E+ ^2 [, O; G! B.. abc ab
& {* ?# {0 v  v/ E
0 f9 _: ^$ c2 C+ [  v"+" 代表一個或以個以上的字元
; m& @! ]( ]' c% j  I"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
& [$ p$ o# c7 K! F# A5 _/ B8 P+ ab ab
6 d! E$ j' W5 P! O) J, s$ z* abc abc
8 v* a0 W7 q' B6 K- G8 a
"( )"群組
& ?3 e) t' }6 V+ ]7 p  z2 s
正規式 原字串 符合之字串
6 j+ f' }0 V0 |- a) }* P& t. s; i(ab)* aabab abab
7 D  J0 I8 ^# o/ O" R0 u0 K' E
字元類
5 _, D9 T( ?! o; `+ c- b/ Y8 r. b
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
1 _7 b4 v$ l% ]/ w" @: _3 b[a-d]* abcdefgh abab
, O2 x* Q6 R! P. s9 J0 N6 Z
+ ]2 M2 L' j) E  W
簡式

\d 等於 [0-9] 數字
( h# c) _/ _# R9 p* {\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
1 I$ J: _; Y: g\w 等於 [a-zA-Z_0-9] 數字或是英文字
* o5 W( ?7 E' b5 l0 D\W 等於 [^a-zA-Z_0-9] 非數字與英文字

; ]8 d6 \8 u# f% ~9 a; W每一行的開頭或結尾
0 z7 a  b' i+ O
^ 表示每行的開頭
$ 表示每行的結尾

--------------------------------------------------------------------------------
" ]  {% `( u% w6 Q1 {
正規表示式 java.util.regex 相關的類別
. ]2 |% X$ I) b9 E. m2 H) ~: j8 m
* L# I% e* m% [Pattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

4 M# L  A0 C8 Z8 N3 p範例1: 將字串中所有符合"<"的字元取代成"lt;"

( C8 x% ]9 b, E: f4 [+ Mimport java.io.*;
5 @( Y' }5 ]6 kimport java.util.regex.*;
  e' r2 Z, ?0 S/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
5 l! |1 s# m, R# s3 j1 @// BufferedReader lets us read line-by-line
" w1 k& Y$ h+ o& y, q6 y& M- aReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
/ A7 n1 @9 f# Y* Z$ pPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
3 E4 d$ P0 T+ @( H2 z; G. Y: Rtry{
while (true) {
3 L* i3 Y2 w1 n" i8 Q* P$ t( gString line = br.readLine();
// Null line means input is exhausted
1 ^3 J/ X  ~, M5 Y; E" o4 @( Vif (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
: v; a; [. L  t0 zSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
5 N8 m& D# D3 }}catch(Exception ex){ex.printStackTrace();};
0 Q8 g3 g' I, c" Z: s2 a}
1 S5 S0 `( G5 M
  ?0 L9 U+ |2 Z, b範例2:

0 I# k5 p: r2 N- W! a- M* u5 [import java.io.*;
- N5 q; P9 J' t5 C+ n( bimport java.util.regex.*;
/**
* 類似StringTokenizer的功能
! }( V! v& c0 M' c* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
2 K6 \. Z% I. P$ `8 g// BufferedReader lets us read line-by-line
' P8 j$ Z1 @5 \" Z# TReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
1 Z8 o7 M& a; o8 H# i" iPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
# o) {+ n- a' ?5 N' F# Q3 rtry{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
: V* l0 s! T" X9 G; K) Vif (line==null)
break;
3 |& }# _3 G( p// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
& L9 B, U7 m# O8 |9 l6 H! H/ qfor (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
longest = i;
' N' d9 L3 ~% @# RlongestLength = words.length();
}
9 a- T% h: `: X3 G* D7 N7 h! i}
2 t9 h1 ]' C" tSystem.out.println( "長度最長為:" + words[longest] );
  }' ^7 H* u7 ~}
; ^- n# x; M( ]/ c  F}catch(Exception ex){ex.printStackTrace();};
: u# _, t: @/ O" N* e6 A" h}
. ?2 ?5 a/ N4 Q: E- u. ^! a
--------------------------------------------------------------------------------
! O- j( l* _  q( u
5 q; I# [$ X$ }' P3 ^) |3 ?5 i9 F其他的正規語法

& y" @9 k2 ?- F( w0 E/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水