关于正则表达式---ZT

Longe

第一部分：
) F$ W* a* D4 u/ P- \# e-----------------
5 G6 s0 x: }/ a. D, V7 n0 g: p正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。

支持多种平台


正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
9 }3 N! r- i1 i) ~
$ p  K) E9 f/ ^- l$ h+ b: D正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
- }7 i" a/ _9 S" I6 R$ [* c
许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
8 o2 U, g0 w5 M( w1 l& z9 D
比你想象的还要普通
3 P8 L3 N' x, q, ?3 `随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

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

第二部分：
----------------------
字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
% Y' K7 G0 u: u6 a) s
每一个表达式都包含需要查找的指令，如表A所示。
  H$ w- _. y* t/ w# l9 u
Table A: Character-matching regular expressions
格式说明：
" c) `  F7 N2 I) c+ @1 e---------------
2 N, O2 j5 _9 [1 r( w7 ^操作：
; M, m/ Q( e" [9 N. ?2 `% _解释：
6 e& _2 U9 H2 M例子：
结果：
# [- Q2 u; P! p3 c0 i% w----------------
9 N3 p3 R' n$ ~( E  G.
* F6 Y6 C, u+ y, tMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
: c( x% {8 r  O! n& V, n-----------------
% h0 ?# f+ p. ?; E4 n[ ]
Match any one character listed between the brackets
) N+ R, _! l; sgrep [cng]ord sample.txt
" J/ E, m1 d4 y5 uWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
Match any one character not listed between the brackets

grep [^cn]ord sample.txt
# S& a% }% I8 M; @: x" q! RWill match “lord”, “2ord”, etc. but not “cord” or “nord”
' T- D& J2 s5 ?3 O1 @+ p
grep [a-zA-Z]ord sample.txt
5 x9 z: n, q$ A3 h/ QWill match “aord”, “bord”, “Aord”, “Bord”, etc.
& Y+ a2 Q3 H7 S6 R+ v9 O+ h
( Z- E8 R8 H' K+ Ggrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
- }6 @5 p  N3 Z6 g5 W
Table B: Regular expression repetition operators
: M+ [4 ?" O7 u# d# h4 W格式说明：
* z0 F  b( c, B2 t- U6 g+ u5 |7 J---------------
操作：
解释：
例子：
+ o5 H9 u/ |1 }/ n" d$ m结果：
----------------
?
8 h; H6 x6 ?" b4 a  Z/ a% H, O& KMatch any character one time, if it exists
egrep “?erd” sample.txt
6 X  q* X$ O" M- Y( yWill match “berd”, “herd”, etc. and “erd”
------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
' _/ V7 A$ h( s8 U' v- r* ]Will match “nerd”, “nrd”, “neard”, etc.
: S% J! u' M! @: j( m' u3 i* C-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
{n}
% ~2 T3 t5 D7 _+ f) @) ^9 l/ V! GMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
' ?% Y& R* \1 u; I6 }9 Y% `Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
Match declared element at least n times
1 y+ ~! B. Y$ Y# k: ]egrep “.{2,}erd” sample.txt
2 H' T3 R6 G. z+ [$ Q3 Y$ t7 E( ?Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
% e5 |# q; ~1 w6 J. j: `9 {9 bWill match “nerd” and “neerd”

第三部分：
----------------
锚
. E# X7 G. I& Y7 R- J锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/
8 x) o+ Q% x+ O% K' G8 X% `
4 w/ A( l! e" r' H7 a/ U' d( P
Table C: Regular expression anchors
6 h9 ?5 g2 ~0 ~& d. z8 b-------------
' s" B; _2 I/ V6 Q1 C操作
& l: A  \7 n- b解释
; p  x5 u" o! K9 M" x8 L" _例子
结果
---------------
^
Match at the beginning of a line
s/^/blah /
4 t3 O" g6 e; }2 I2 z4 {# q- t$ V+ fInserts “blah “ at the beginning of the line
7 ?6 t4 q9 ~% U5 ]1 a---------------
% n% m* D  N& q, ^4 U$
5 n' o+ ?3 P+ S$ P& {Match at the end of a line
s/$/ blah/
, x6 x0 R* k$ J, _Inserts “ blah” at the end of the line
---------------
\<
Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
- ]6 S# Y- Y3 y3 H
4 E! O" j( M2 v! ?$ L) regrep “\Matches “blahfield”, etc.
------------------
0 g; v: [$ j; b5 Q\>
0 {: F; c3 Q9 u: w1 g2 zMatch at the end of a word
s/\>/blah/
0 N9 z- A% l3 ~4 ]4 a& f, ?Inserts “blah” at the end of the word
/ F/ P  Y7 g' A- k
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
; e' x# S& G7 g# p2 J( w---------------
\b
Match at the beginning or end of a word
& M1 }% P1 F4 ~( W4 d6 ?egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
* f7 a4 Y/ G) }\B
Match in the middle of a word
4 p! T- h: j/ Y, R3 E* }8 W# Tegrep “\Bblah” sample.txt
Matches “sublahper”, etc.

. v9 r0 b: T5 j+ C; u7 q间隔
. B! {( o) e5 N  |2 u0 S" g
. Q, g) T# `  Y. v' TRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

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

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

egrep “[nm]erd” sample.txt

0 V1 q6 ~# W# `! W! K5 [) s# C当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

第四部分：
----------------
& l6 w- c$ D+ {( ]2 V; F一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

0 w! p% S4 U0 C0 N& d^ (carat)
) u: W! m6 B$ V1 f1 N! J2 A. (period)
* h. _4 D) C6 [! O9 [; a" c+ Q6 H4 B[ (left bracket}
$ (dollar sign)
% a, a  Z, r4 ~* B& d# s( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
1 p" N) i* D& H. M+ (plus symbol)
? (question mark)
( G4 S; i0 D" {{ (left curly bracket, or left brace)
\ backslash
2 Q0 I3 ?  f, N一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
, q0 A% o0 @, D6 f0 j2 _" H
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
' C6 \0 q! O/ A% J$ }0 _
另外一篇文章
; R0 s1 N  `9 O3 j4 S8 ?5 x- r----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
* e- U9 O$ g! d类和方法

下面的类根据正则表达式指定的模式，与字符序列进行匹配。
7 f" {8 @; _2 H3 S. v
Pattern类

, E/ H# ]# ^' U  q, u2 ]5 }% APattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。

) B, o- Z$ l& `# W# n7 j9 o9 j+ D用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
3 j+ s+ M* U) h. [, U9 A. W
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
5 [+ f' a( f9 {% C. o) w2 V
% K# J; t+ v1 m/*
8 q( w$ F) O% `2 n& \* 用split对以逗号和/或空格分隔的输入字符串进行切分。
/ X( u! V# X6 p  b7 D6 r9 N*/
import java.util.regex.*;
  M* U% R( K: b9 }! N7 p1 c
. T% T3 U$ x9 t/ G0 Q6 m9 O# _public class Splitter {
# ?* k" J$ c+ Upublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
, l" v) t  ?+ L9 e4 FPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
; n5 B/ X0 s# B" |$ r1 i$ \String[] result =
   p.split("one,two, three four , five");
" c& H: g+ _: [9 k  ?for (int i=0; iSystem.out.println(result);
8 F! Y0 `2 H; p$ d8 F  {! }3 h4 D- ^}
3 [& O& d! ^8 r2 q}
' q; ^7 G/ o% p9 m) ^
9 f! F& f; ?  n+ P: u+ J& ]Matcher类

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

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

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

1 ^% I* K/ x' b( y% N这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

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

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
: ^1 n: O: [' D- ^+ E1 R
8 |- f9 S- H' n  ~例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

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

5 }5 s: y7 O, J" ?" `3 v4 u+ `4 bRegex情景范例

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

0 F: F7 |% w% _- e  o简单的单词替换

/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
( B3 o5 C9 n  V2 ]9 H* Oimport java.util.regex.*;

6 m7 m& `. g" O% Bpublic class Replacement {
- b& K4 d! I6 Z3 K; `) R0 q+ T! }* U* N  Hpublic static void main(String[] args)
$ Y- F# v3 H4 K4 \( i0 C* e       throws Exception {
9 y$ C2 j1 U; y9 ~( s0 S// Create a pattern to match cat
+ }/ W, w' }- }8 R$ z3 L; FPattern p = Pattern.compile("cat");
// Create a matcher with an input string
4 H0 p0 O  a" d# {Matcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
2 p/ m; t6 a* M) b# c! r3 b  }boolean result = m.find();
( P  }' T6 [$ Z# j( C// Loop through and create a new String
// with the replacements
; b5 K- L% s0 Y; x/ E+ I' R# vwhile(result) {
m.appendReplacement(sb, "dog");
8 z5 J" `# u0 t7 i  n* _0 ~1 Hresult = m.find();
5 B4 a* x+ {8 P- p3 s) H}
( ^9 M+ F9 W9 k% F$ a* {// Add the last segment of input to
// the new String
& b( Y& g' c  ^* [4 @  fm.appendTail(sb);
System.out.println(sb.toString());
( S4 T* a7 M. c3 h: C8 u6 C}
& y! t9 P3 A* U( `" f$ e7 ^" g}
# N- D; f' e# {# {# D6 H
电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
% p; W, ]+ b$ X. \3 P+ ?# G8 n
4 |. ~, R3 q9 G4 `4 ~/*
2 O# g, H9 x6 ]1 \" V, g- H* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
           
String input = "@sun.com";
. Z0 ?, h% ?& I8 w0 X; V//Checks for email addresses starting with
+ L8 A- d7 |8 M) @//inappropriate symbols like dots or @ signs.
. i; Y3 \) ^( k9 T9 W5 z# ~: hPattern p = Pattern.compile("^\\.|^\\@");
7 M) A2 W* C" E; s8 g% zMatcher m = p.matcher(input);
if (m.find())
, V- W; b% V7 `System.err.println("Email addresses don't start" +
/ a' a1 y& f0 d: d# d4 W, I         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
) L7 ~: Z7 d+ X4 D$ N  Lp = Pattern.compile("^www\\.");
/ A( j: Z9 t. o! p: l' d: ^m = p.matcher(input);
0 D+ |6 Z- ?2 O2 Mif (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();
: T% O8 m$ Z+ F8 l5 Tboolean result = m.find();
boolean deletedIllegalChars = false;
2 D2 s0 _! }+ _
. e: ?+ i* G* ^* w. mwhile(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}
7 c+ Q6 V2 n9 k: `; q
; M& D: D+ }! W3 O6 o  s- k// Add the last segment of input to the new String
; H* X& Q  X* |1 L& Dm.appendTail(sb);
3 Z# ]9 |. w1 G# \+ }6 g7 [
input = sb.toString();
5 d: h' K" I& t/ u* i2 j+ n
1 B, o& K, U. P/ pif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
}
}
" ]" E6 }3 x3 J' j7 M% Q}

& P6 b9 R9 _* R从文件中删除控制字符
7 U, d* E8 r) @1 g
/* This class removes control characters from a named
* file.
*/
' Q9 h& @1 n8 W/ X" s# wimport java.util.regex.*;
, M0 D- l  S4 u, J" ~! Zimport java.io.*;
; ?1 |( M" m) Q, ^7 R: V; ^# J. G. |
% [0 K% ~3 k( ^- \4 m# x9 a; R: apublic class Control {
' D# L1 m* k! i3 I  n0 Y& a( Q! mpublic static void main(String[] args)
           throws Exception {
: I8 z( v0 R1 s. k$ m1 ^* z7 ?           
//Create a file object with the file name
//in the argument:
  m) A6 t  \  S$ d/ `" u, y! mFile fin = new File("fileName1");
File fout = new File("fileName2");
' N. g) t* x3 ]! ]" l6 G! S, H//Open and input and output stream
FileInputStream fis =
, U; ~0 O1 t, _8 t% j* R' H       new FileInputStream(fin);
FileOutputStream fos =
+ k1 J* I  R7 z, F3 X, p$ t% }       new FileOutputStream(fout);
' D0 M" \- m/ x4 L
BufferedReader in = new BufferedReader(
, f0 x0 D% r! B6 [     new InputStreamReader(fis));
6 s1 U! S/ n5 I! k& g. WBufferedWriter out = new BufferedWriter(
2 k2 L5 j$ @' T% u: r% E; }8 y     new OutputStreamWriter(fos));
0 w6 N" v) m! {
// The pattern matches control characters
; ~) ]$ c1 H% p4 }; m- q" ~# XPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
3 K1 ]7 P" a" S1 ^1 N8 ?+ G' bm.reset(aLine);
//Replaces control characters with an empty
//string.
. u# r* \8 x: D7 U$ O; cString result = m.replaceAll("");
out.write(result);
# w/ N3 {# N9 Y5 q4 h+ fout.newLine();
}
in.close();
4 f$ F/ X' e' D# G& ^out.close();
}
) R/ U2 W2 |; D& P6 V: J) O}
0 t" C: ?; [% j* w+ H1 |9 Z
" |5 D, D" d, Q0 H9 }文件查找
0 d4 A( {$ P5 r0 h
2 ?6 L! @: U! n/*
* Prints out the comments found in a .java file.
1 ?7 y- d4 {; v0 E1 p*/
( \/ A$ H+ d1 R' Cimport java.util.regex.*;
import java.io.*;
/ F1 H, L5 M4 T1 j! limport java.nio.*;
3 U" u4 \6 @, Y& R& U* J) T6 eimport java.nio.charset.*;
/ v% f; F- A3 m: V( Aimport java.nio.channels.*;

  f7 R( h# c0 V1 Gpublic class CharBufferExample {
6 g8 T2 Z- m* {, @/ Ypublic static void main(String[] args) throws Exception {
/ c% y8 s# L2 C1 f9 I// Create a pattern to match comments
1 _  ?# M4 |  u  z4 W4 XPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

& x. y; Y  w& d/ H// Get a Channel for the source file
File f = new File("Replacement.java");
5 ]$ \( r0 n2 Q9 h& i# ^! qFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

3 z) F8 B% ?0 J& y9 H6 |// Get a CharBuffer from the source file
ByteBuffer bb =
' Q+ t  F, Z$ F3 c" T6 _- Ffc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
/ b# Z  W/ a- C' p* L3 Q1 B  kCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

, ~, P; d# v8 T// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
2 M  f1 |$ ?$ x; a0 I1 ], xSystem.out.println("Found comment: "+m.group());
# I! J9 Q9 u0 \. Q4 ~8 U; B5 d+ R1 C}
}

% m; f' F% f" ]6 f* d' }, Z结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

! s* w7 ~% ?8 {- c7 f8 f: _$ ~0 NJDK1.4之正規表示式
written by william chen(06/19/2002)
) H& W) W7 P/ Y! ]* |8 r! F9 R- X
) b( j3 h: a) Z. Z--------------------------------------------------------------------------------

什麼是正規表示式呢(Reqular Expressions)
6 z& F8 h9 q: P2 O( |3 r
就是針對檔案、字串，透過一種很特別的表示式來作search與replace

因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
+ O) c. l/ `5 b: m3 e, j. u
所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
6 T) I+ t/ l/ h, C4 \
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
" c0 T% a/ l  C5 S' V& w* L0 i
剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法

% U; X+ F2 w# B+ ?5 ~. j9 m6 s"." 代表任何字元
6 U1 u% Y9 f+ j% L0 ]* L
正規式 原字串 符合之字串
! [: d) K( J# w" K/ a. ab a
.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
2 q$ B8 j' Y- y. N0 W6 H' s
正規式 原字串 符合之字串
! v. K! w# t) c" j' k+ ab ab
6 W( O2 ]+ @+ d1 J* abc abc

& B. p! A* \7 z+ P! t"( )"群組

0 T; A, w3 H5 L( [4 n正規式 原字串 符合之字串
(ab)* aabab abab

字元類

正規式 原字串 符合之字串
; _1 a2 l( ~$ x( r& t) u[a-dA-D0-9]* abczA0 abcA0
7 q; V$ [' |' n# V) n& ~[^a-d]* abe0 e0
[a-d]* abcdefgh abab

& ^$ `% e5 T/ {" M8 U0 j
+ Z! V3 ~2 k  Z簡式

\d 等於 [0-9] 數字
0 \5 r' a) A8 k0 P0 ^- v& [5 H\D 等於 [^0-9] 非數字
. A! h$ v! C: n4 N  @, ~\s 等於 [ \t\n\x0B\f\r] 空白字元
8 ~- I1 h+ r6 P5 m\S 等於 [^ \t\n\x0B\f\r] 非空白字元
0 L( [+ `: N* i\w 等於 [a-zA-Z_0-9] 數字或是英文字
$ G" C6 \, q& W. w( g: [\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾
5 l# `7 |3 A# @
! O9 r2 O) m9 d5 m7 F8 }^ 表示每行的開頭
$ 表示每行的結尾

: w* B% I$ F) J" J3 X7 E: M--------------------------------------------------------------------------------
3 t9 q) w* o6 P; j: z
正規表示式 java.util.regex 相關的類別

Pattern—正規表示式的類別
Matcher—經過正規化的結果
: \2 v! K3 C) B- k) q) t# ?PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
  A" z' O2 l7 l& N0 U+ D% |* ?6 I
範例1: 將字串中所有符合"<"的字元取代成"lt;"

import java.io.*;
, O9 U$ I! F, d- zimport java.util.regex.*;
0 Z7 B/ J! k; P8 n2 G5 f  x: _/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
) t9 z4 K$ S' n// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
/ w% X4 j3 H0 ]BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
- A7 k0 S6 ~( s4 b* Atry{
3 i0 z0 t( j2 C0 O2 Awhile (true) {
0 m- d* u( E8 n, kString line = br.readLine();
' @* F0 i  P) z1 i1 E) E1 j// Null line means input is exhausted
) r, y7 j; H- h0 J( d+ ~  v$ @if (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
1 n" ]6 y/ \1 g& c. ^System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
7 W% I+ a' F3 \/ T, k% k. |/ M}
3 b3 J( F; D. u
範例2:

import java.io.*;
* c( Q" g# x  |import java.util.regex.*;
/**
* 類似StringTokenizer的功能
# b( W  t7 w; O- I/ s  U: Z* 將字串以","分隔然後比對哪個token最長
8 I. ]9 q, q  C; t8 L2 f*/
$ r, m% X5 I8 c! N, h. gpublic static void search01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
* v  V/ @0 U) z0 {7 rPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
% E2 a3 j$ i! Ztry{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
: Z5 {( ~% d0 h, k' l' x8 t// Null line means input is exhausted
if (line==null)
; W- @7 g7 y% mbreak;
// -1 means we haven't found a word yet
1 R+ \. y$ [4 B& J0 }int longest=-1;
" H2 b4 z" v  b7 |1 h; x3 G" }+ hint longestLength=0;
3 y) |& s7 d0 d. z1 A" Y  ^# Mfor (int i=0; iSystem.out.println("分段:" + words );
0 l, D5 b# |# _0 s: Pif (words.length() > longestLength) {
4 |" j* j  \. I( n" e6 Olongest = i;
" R+ M" \- O. A3 T4 j+ PlongestLength = words.length();
: V! Q2 b  {8 M8 C0 e7 m; C6 {) [0 ]) f}
5 p* M, R& a+ `3 |}
0 X; z2 B/ [# o5 M& o, {# mSystem.out.println( "長度最長為:" + words[longest] );
/ n: |9 A3 a+ A$ C" J* m}
( ~3 c! Q& e  D, ^  R* d}catch(Exception ex){ex.printStackTrace();};
}

--------------------------------------------------------------------------------
0 k; [& O7 S. a. B8 a
其他的正規語法

/^\s* # 忽略每行開始的空白字元
7 L& Y' P/ L* s(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水