关于正则表达式---ZT

Longe

第一部分：
-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
" N2 y2 |' ]/ L! }  S  n
支持多种平台
% L4 Y4 e* S+ B  j
2 |  N' y% o$ t$ o8 Q+ L7 h
8 N4 e; z3 F) t" }& M) r  l正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
( X! |, d, S- b9 _8 d
2 Q* o: S& c, ~0 P: G3 \正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
1 A7 j8 f. U+ B# U7 u: D
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
; z- d/ t, U3 a) D$ H: ^) Y
比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
8 Q' U5 u1 K( v; l* ?
7 [  i6 [' f2 x  x3 v/ \) f正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
----------------------
. W8 f* c% }* b$ o4 R$ k字符匹配

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

每一个表达式都包含需要查找的指令，如表A所示。
) r5 Y: T8 n4 v2 q( L* x
Table A: Character-matching regular expressions
格式说明：
---------------
操作：
& z/ z7 L: p* C: t解释：
5 Y$ [5 E2 Q1 v. a( D例子：
结果：
. a3 s: }! L% R* t* E----------------
# G+ C; F3 Z. B0 R% ^.
- X/ X$ Y8 Q- }% @  Y* OMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
, T. e. R" c! @7 B[ ]
; J6 H) d% ?6 M' v! ~' M6 \Match any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
6 w" N8 Y$ o( _/ ?[^ ]
Match any one character not listed between the brackets

, y, D" b. }6 C1 U3 Lgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
# P# C  H0 D% M" ?0 f
grep [a-zA-Z]ord sample.txt
4 `) z1 z9 Y. ^" X9 lWill match “aord”, “bord”, “Aord”, “Bord”, etc.

; U; M8 x# v& z4 N' Ugrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
& J1 u. ]6 _/ e3 }- O$ r& g
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

5 n& j0 F9 X  a6 NTable B: Regular expression repetition operators
格式说明：
---------------
" Z. h5 K6 y' K3 J, F操作：
5 O8 r; H5 X# p6 l解释：
- B7 V' a6 G7 k& B7 ~: ?例子：
结果：
----------------
9 l* A$ C. b* z: _4 r7 b  ?& K?
Match any character one time, if it exists
) y/ y, g+ z, f1 p; h4 n2 Zegrep “?erd” sample.txt
$ o6 ^( R( b! P& XWill match “berd”, “herd”, etc. and “erd”
------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
  h6 E. k$ w  F3 b* I# ?. |8 ]Will match “nerd”, “nrd”, “neard”, etc.
-------------------
+ V$ I& v5 X- y, t2 R) f+
Match declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
) z5 r5 _3 P" T& t6 C--------------------
{n}
. _/ k4 r! d) D  PMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
5 \7 \+ G' e; N& K6 m{n,}
Match declared element at least n times
; E# i: D! X) Kegrep “.{2,}erd” sample.txt
' k4 f0 Z6 ?) Q7 A; y, P$ L; K( ]; b# z0 PWill match “cherd” and “buzzerd”, but not “nerd”
8 A2 [: `" w' @  A( M------------------------
  p5 R6 V- n+ }{n,N}
9 s- w5 h" i% w2 LMatch declared element at least n times, but not more than N times
  ^* u2 K- P) T5 p$ v+ [1 R) Aegrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

; h: Q8 m' |" l3 [. c1 f, s第三部分：
; G+ K3 o# B1 s$ x----------------
锚
2 Q1 I$ n1 S0 M. M锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
8 f9 A# q: n; M" s( h/ H7 g+ S
. n7 s* x' O! w* u2 Is/pattern_to_match/pattern_to_substitute/


Table C: Regular expression anchors
6 y3 V+ N" Z8 B0 F  l; Y% ?-------------
" o* Z( B" K! _2 I: p* q操作
解释
例子
% [# @6 @) o7 \# j6 G0 M& W结果
& M* {& f# n. {2 _: }---------------
4 z6 e4 g7 ?- r7 h. J* J' |% c( n^
Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
9 f  `( b" F# Y. O6 [7 b---------------
1 e( _, b7 u+ r7 {( i' G$
1 l! F' r* g# U& }$ U  j+ wMatch at the end of a line
2 c! j3 A+ _" Is/$/ blah/
Inserts “ blah” at the end of the line
---------------
\<
. Y; z- ?, z$ OMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word

: P# x+ W  s" q* ~! o$ Begrep “\Matches “blahfield”, etc.
8 B8 J4 ~6 x: ~/ B" G------------------
, S' a7 ?. d3 p# W  {  j5 B6 @\>
Match at the end of a word
  g: k* v# ^% q% T4 f* Js/\>/blah/
! R: m0 a4 Q4 h8 r. N9 J/ ?& gInserts “blah” at the end of the word

egrep “\>blah” sample.txt
8 k+ k+ m# H+ D: i' e: B& [; MMatches “soupblah”, etc.
4 }: s/ ^2 c& x) Z# x6 `5 g---------------
\b
6 d* e# j2 l/ Z/ s. Z0 }  zMatch at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
- U- U: d  c5 P3 _: i\B
Match in the middle of a word
egrep “\Bblah” sample.txt
& Z/ a0 z9 T, C: cMatches “sublahper”, etc.
5 s! Y& N! z# l3 L4 ^3 I. W5 p
间隔
& S+ o' c  G8 p( A$ A" `
! D/ X' |; }+ W, M9 o* d5 pRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

- C0 T: X! C' g" l: `egrep “(n|m)erd” sample.txt
5 w1 J7 @; U0 a- d2 N; [( `2 J
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
5 c9 q2 i5 O; C
! F, Y  b5 A7 L- `; J& ^; xegrep “[nm]erd” sample.txt
! ^5 c  V6 W! _$ Z( X$ |2 q
当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

; O. q% q2 c. V$ p5 [3 D) v第四部分：
----------------
0 R$ F- T! `1 u" Y一些保留字符
+ L" n/ S4 {* _6 _Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
2 I# k$ R7 Y& N- O
^ (carat)
. (period)
1 \$ t9 i0 c, j* `- R5 |6 y$ u, p[ (left bracket}
' ~  f' z3 y* j  ^  d; a$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
| (pipe)
( V2 x! _# Q2 L$ z: ?4 _( i  Y1 ?7 @0 |* (asterisk)
% r. j9 W/ o* D9 d% b, ~( s+ (plus symbol)
! k. L3 v, f" |! \? (question mark)
5 _! R# x4 r# N  u{ (left curly bracket, or left brace)
\ backslash
/ _* h$ F* g' I: I( ~一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
$ b: i( B" p' S0 x
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
/ v# f+ ]4 w2 j7 l/ E4 s% E. K8 n6 \
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
6 C2 I! F9 Q# e+ w" ~+ u
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
: u. P0 B2 l, T6 a$ s
% Y) }) q. U4 t) X另外一篇文章
----------------------------------------
8 O1 u6 o0 _8 e5 R1 R正则表达式和Java编程语言
/ v- r6 J* H1 q% \, s5 Q-----------------------------------------
类和方法

' f/ @6 S( H2 a/ v下面的类根据正则表达式指定的模式，与字符序列进行匹配。
2 z9 }& e+ l( `
Pattern类

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

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
. J# q; n9 j  b4 ?  J1 W' x
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
& m3 v4 [# l4 H3 ]7 N
) m7 M) F7 |) y% ysplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
5 l* p% M6 Q, y! v
: g( [& s& Z; I2 Z1 q+ V. Q- ?6 b/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
3 w' J2 {( A2 a, v4 B) h% D* S*/
import java.util.regex.*;
8 X5 S1 U: S8 l# {! I5 z
1 L- B9 n4 E/ O( z; A7 Rpublic class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
' H' C' V# s, K+ R. S7 W! a% H// Split input with the pattern
String[] result =
' S/ ]- ?  M" e, _   p.split("one,two, three four , five");
' q4 E! I9 Q0 A$ ]: pfor (int i=0; iSystem.out.println(result);
}
}

Matcher类
$ K* \: |& W8 P+ _
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
3 T, z+ }( h( l( Q
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

5 L/ B; h1 ?& [* L6 I) [5 V2 a这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

, j0 r) D' L1 y; h% @这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

/ j0 i! W, h3 M/ l7 D: {% \appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

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

CharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

Regex情景范例
4 A% M9 N; a, d" s, v7 i# j5 e* h' o
4 v7 I( t8 n3 V% n+ x  @5 h+ ]以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

9 v/ l5 U% x/ x3 q4 o简单的单词替换
! x6 o- ?% r5 z. I
/*
2 Y8 T4 J% Y4 B6 [6 s: U9 R* This code writes "One dog, two dogs in the yard."
% _9 ?1 s. `3 s# q0 j5 r* to the standard-output stream:
, R' D8 x( D7 h) p; X*/
$ U$ e# C9 X+ F: G; E" p- |import java.util.regex.*;
7 y3 c9 V' s9 A- {% |" u
public class Replacement {
$ E- H& d/ F8 n" B7 Bpublic static void main(String[] args)
7 u8 K  Y5 V7 C9 L1 Q, D       throws Exception {
' A* b$ l. I/ ?6 }$ [9 B// Create a pattern to match cat
5 j; L" x0 m) Z+ z. ^: _, hPattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
+ p6 |+ U7 X/ T. }7 y4 S5 K     " two cats in the yard");
, P/ H; d( Z. s- s( EStringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
( Q( C( R/ l# b2 T4 w- ^// with the replacements
1 G5 `" f5 K, q5 E# @+ ~" g; ywhile(result) {
, w! {3 ~. G# Q2 _, F$ K* W; }. }m.appendReplacement(sb, "dog");
" C6 p( H1 \% Dresult = m.find();
. r' C! ?) \+ x& v}
// Add the last segment of input to
7 j2 y. }3 Q9 b" v! D' b. _// the new String
6 D4 r4 T5 T' V4 Sm.appendTail(sb);
System.out.println(sb.toString());
2 V( S& x2 x4 G: ?3 }}
4 I! q1 g: E, U3 n" t/ Q}
1 |: s  m/ x3 C2 M3 l( u8 i. L8 m; c
电子邮件确认
( t0 b9 J% v- s* W: A& t/ f
, U6 l, n! U; K& M以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
, X/ k0 r: n: }9 ~' \
6 s( l: d3 Z( f, N8 C9 }. l/*
* Checks for invalid characters
3 x- I( a9 ?% I3 [9 S! ]* in email addresses
$ x, H% u# B4 n1 F) ]*/
public class EmailValidation {
2 C9 B# h% g( v2 e: O  i0 lpublic static void main(String[] args)
- q. d3 ~! \+ ?- e  }- i7 e           throws Exception {
- v3 Y# `) Y5 `; K           
String input = "@sun.com";
//Checks for email addresses starting with
; W6 d; j- b7 e6 i6 E//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
( K3 O9 h; V" M' S2 TSystem.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\\.");
m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
8 `* Q0 m/ ~) i' n+ y) p
: S1 ^% h9 \' q1 V( j; mwhile(result) {
& p) N! @$ b8 y# u8 X* @deletedIllegalChars = true;
m.appendReplacement(sb, "");
" u# D( r1 [5 }+ `) Y( `result = m.find();
}

# \, b3 v7 W& _3 y# Z, e/ c// Add the last segment of input to the new String
+ m9 o) W2 |# F9 g3 Bm.appendTail(sb);
* P  D4 }( R' n- ^0 n
input = sb.toString();

if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
}
: M& D( m+ n' k
! ^# F( W3 ]% ?1 |% J) u" c从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
& |0 {) N9 i3 Q# u6 Y! V: m2 |% t, Timport java.util.regex.*;
import java.io.*;

public class Control {
public static void main(String[] args)
           throws Exception {
) l1 O" s. Y0 @2 l" a& r7 M           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
! _% m1 Y% Y2 @, ?& j8 o" A: d4 sFile fout = new File("fileName2");
//Open and input and output stream
, @' P7 z2 P* O8 @  ^FileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
  }' s1 s% b& h$ n
5 E5 j6 t: J& f1 SBufferedReader in = new BufferedReader(
* [8 D" G& ]9 q& N9 q/ ]$ A! [( \     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
* X1 b  ?, X+ [" r! s
// The pattern matches control characters
* k; l! s" R5 x0 H6 L5 tPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
, M3 x: ]- X6 \$ @3 nString aLine = null;
while((aLine = in.readLine()) != null) {
5 z5 s/ j  I1 ym.reset(aLine);
//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
& @+ O# ^! s- g( Jout.write(result);
out.newLine();
3 k$ T2 Q* x* |}
in.close();
out.close();
}
}
# T# _: [; y, R
5 @2 r4 \+ m6 p* u% j: z- _4 G文件查找
& V2 ~7 r& g# o6 R
+ _. Y4 ]" [0 Q' T  m2 J/*
3 C3 l# J) o! Q% I* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
+ U( A& k- l% Q1 Z% S7 B' W; v& V4 |import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

' ~" G. z7 s& O5 cpublic class CharBufferExample {
: d2 F* k# C6 d0 ]3 N+ E& p( upublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
) n2 U0 c7 g1 cPattern p =
( s" l6 p7 c9 O$ b; C6 \Pattern.compile("//.*$", Pattern.MULTILINE);
/ p  a; t  G! A
# x  W  T$ w* h// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
+ R% g( p4 N) zByteBuffer bb =
4 x0 i8 h9 N) S8 K* _+ \6 Dfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
1 ~3 n9 ], D# f  [Charset cs = Charset.forName("8859_1");
/ e8 j' q' f$ [7 Y8 h& Q5 e1 iCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
7 o, u4 L: M4 ~- _8 B8 ~
// Run some matches
+ Q( U/ J" \9 P& B  r$ qMatcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
}
, |. s6 ]5 f+ N
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
& ~4 V' z3 Q2 D4 o/ u7 l% A: X* @) Swritten by william chen(06/19/2002)

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

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

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

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
' S: @. ~6 b% j6 ?* Q" P+ b6 l
) @; I0 J% V4 z1 o* t. V% f/ P9 g所以發展出一種特殊的命令叫做正規表示式

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

3 @$ m% b' y4 I1 J若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

2 F, ^+ Q& F7 f4 w剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
/ p- t7 m! p: Q. {! u3 Y
) E+ F. b0 |, M' n( P"." 代表任何字元
/ y2 @+ Y# ~5 p- @# m3 L
正規式 原字串 符合之字串
. ab a
.. abc ab
; O* F$ @- d" [8 K* ]3 L$ M, _5 Z
"+" 代表一個或以個以上的字元
" P4 J4 W' Q+ i6 q; N9 n; v"*" 代表零個或是零個以上的字元

% `0 T# w' C& B- ^正規式 原字串 符合之字串
+ ab ab
! W+ T3 e2 C' D, n) x* abc abc
0 _6 ]- \4 A/ ^( U3 l7 C
, P4 v/ Y# d7 H) {. V* b"( )"群組

正規式 原字串 符合之字串
" }9 Y. K/ S0 u( H2 c; ?9 z7 S" F(ab)* aabab abab

7 ^) z) Z! ]" X. L7 W0 Q8 q6 S8 _3 \字元類
3 P8 ]# d1 q% _9 J: l6 T. R2 P
1 z, k0 o6 g; D9 }9 X7 p* X正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
; _2 F7 ]% T6 |: E1 m2 u[^a-d]* abe0 e0
8 K4 h; |- i5 g# z4 k[a-d]* abcdefgh abab


/ d3 [/ K1 n$ ~簡式

9 Z% C; j/ T9 k) o\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
" x! f) P- [/ Q1 W5 A\S 等於 [^ \t\n\x0B\f\r] 非空白字元
! o6 H3 @, [6 B: U4 H  o\w 等於 [a-zA-Z_0-9] 數字或是英文字
! ?, J: m5 E  V- r  F8 v. M) ?\W 等於 [^a-zA-Z_0-9] 非數字與英文字
" {! B$ E, m& U. u# j: z* A/ Z
' E5 M) A. E5 Q  Y每一行的開頭或結尾
! {6 j" Y3 W( T* g" Z8 Y
& d2 S) {) |* W5 g% ]4 s% p/ ]6 x^ 表示每行的開頭
8 ~7 H2 E3 f6 K$ 表示每行的結尾

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

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

Pattern—正規表示式的類別
. [% n5 h4 Z" q+ ]$ qMatcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

範例1: 將字串中所有符合"<"的字元取代成"lt;"
7 l$ T  j7 Y; I" i% K7 f
import java.io.*;
import java.util.regex.*;
/**
- P+ k5 N9 w: O/ }+ z/ h' s* 將字串中所有符合"<"的字元取代成"lt;"
3 W% x, _9 i' x  s; }: q*/
public static void replace01(){
  N7 H. f7 J  \& U" T2 k4 w! |// BufferedReader lets us read line-by-line
6 [8 A  o, T; q$ r  iReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
9 X$ l# @( e! O" ytry{
while (true) {
String line = br.readLine();
2 k5 L1 F2 i- Z; v. `) a// Null line means input is exhausted
0 x" i5 X; X0 v: l* f& Vif (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
  d3 z' N* |6 Q' ~3 R: O9 FSystem.out.println("搜尋到的字元是" + a.group());
& I$ I7 Z7 t. x}
% x) Q% O) ]2 Z3 k+ V/ t$ FSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
}
- a; Z0 l( q- J+ B
範例2:

import java.io.*;
* b( l# Q! r* Y0 o9 `import java.util.regex.*;
. o. M3 h" i2 T; I3 V0 U/**
* 類似StringTokenizer的功能
2 F$ F) `) }) M1 p& I* 將字串以","分隔然後比對哪個token最長
  L8 e' r# {5 A! u/ X  V- H% F*/
public static void search01(){
+ w7 B( g* y( C# v  N// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
" L' p$ H3 k, T( v7 Y( N/ e3 u; jBufferedReader br = new BufferedReader( r );
" ]; b9 p# y0 }8 S) y$ S- k; h" ePattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
+ _. h* B6 H: U$ L' H3 Rtry{
while (true) {
String line = br.readLine();
# @, K! K' n% ]$ k0 aString words[] = pattern.split(line);
0 i0 B+ f3 |' R. ^# E& Z6 |; J// Null line means input is exhausted
. n5 z; ~4 Z. p7 l8 @if (line==null)
5 b5 ^/ f/ `3 v* E. Ibreak;
/ B! o& l3 G, D; _! ]// -1 means we haven't found a word yet
int longest=-1;
. O' h' |3 o! s! \  mint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
& i) }/ D" q6 E: T2 O/ }if (words.length() > longestLength) {
0 ?$ |& u7 }! w* V9 [3 Blongest = i;
longestLength = words.length();
6 a* v. W& F! Y5 O# @' M}
. B9 ^% P1 B; d9 j% L( Z( M}
System.out.println( "長度最長為:" + words[longest] );
}
}catch(Exception ex){ex.printStackTrace();};
}
7 C$ X9 S3 S& V7 r) B& F; {2 a# `
# |9 F) }# |& H$ l1 J( X& R--------------------------------------------------------------------------------

1 x; k* ?2 P8 W3 |" f' l其他的正規語法
) Y- ^# m; s$ q- ]2 |
/^\s* # 忽略每行開始的空白字元
# W& o; d' W' X9 _( q' W5 E7 b(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水