关于正则表达式---ZT

Longe

第一部分：
) D6 G! n. P  g: g/ Y# l  B, G-----------------
正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。

; Y0 D3 \2 q9 i% c; J2 U支持多种平台

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

& q. D- z5 r% ~; I' y7 ~# V1 k, x正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
) [  G/ N( H; v: N7 y$ S( ^' T6 z9 E1 E
2 W. k" W7 s* I8 [4 F! E许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

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

: t. N* [( q6 j, O正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
8 _! n- U  @) F& B' E; |- ~
* u) ~( W% ?/ @1 y4 m- Q第二部分：
----------------------
% Z1 _7 v: h" N* y+ f% p: H字符匹配

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

每一个表达式都包含需要查找的指令，如表A所示。

Table A: Character-matching regular expressions
% R6 v4 x$ V3 a6 @5 V' z5 ^" S3 o格式说明：
0 Q! o% p* @6 g8 g# Q---------------
0 C: e$ [4 d5 T' P操作：
解释：
例子：
结果：
" Y; u  l. G2 c1 t; }6 f0 N----------------
- P0 g$ N7 @$ d1 `6 ]5 W* R.
- u9 z0 U4 Y) x3 l$ pMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
( a9 r* j3 N( v' f  c5 O$ l-----------------
" w7 }& _5 V9 y& M, S0 t0 \7 `6 c[ ]
! H- n4 l+ q" Q6 lMatch any one character listed between the brackets
/ l: d2 a1 ^9 N. ]) Q$ Agrep [cng]ord sample.txt
2 p9 K6 `$ E+ l* {2 eWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
( l( Y0 E. v4 z: q& a9 w& O' V8 ~8 aMatch any one character not listed between the brackets

: E+ f, P7 `# v; V5 Pgrep [^cn]ord sample.txt
) E; h+ t8 _* @4 Y  r4 }Will match “lord”, “2ord”, etc. but not “cord” or “nord”

2 m! h3 O* n5 ]/ u9 w+ _" egrep [a-zA-Z]ord sample.txt
7 E0 }5 I$ j7 f6 e: Z' \Will match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
5 |* {$ Z1 ?5 O. S. f3 J; AWill match “Aord”, “aord”, etc. but not “2ord”, etc.

. W7 P5 I- y3 X2 |* ]/ [0 l9 H8 I重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
- F$ |$ |- c. L) E8 {1 g4 u) b
Table B: Regular expression repetition operators
格式说明：
$ v4 G3 J; @( k3 M6 n- X( n0 A---------------
操作：
8 P  u+ n7 B  f解释：
  d' t" ]" g( F3 H/ D6 B例子：
5 j% d1 s0 l! _% D结果：
. ^! @4 `: }9 b  B4 R9 a- v----------------
2 L& E, E# j2 F# G?
3 h* j; w* X6 b. k: P: yMatch any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
6 J% X) L1 \: d7 y------------------
- C  H9 s8 ^( G' p# b: i, @*
  l! A, S5 @1 l! v" A' w4 GMatch declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
  y5 B' U: m4 h8 s+
9 D$ \8 s! p. {; N) ^3 _+ x% wMatch declared element one or more times
# N! E6 v& H7 g# Tegrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
--------------------
3 a! O7 l2 n. b- s{n}
Match declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
: L: {' }( R( I; XWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
) h9 H* A  H% v+ |/ P6 Q  C, U------------------------
: h0 d7 s+ `8 q9 I' ^  }6 s{n,}
Match declared element at least n times
! ~1 I) H3 U( T6 gegrep “.{2,}erd” sample.txt
  ]# b2 P% N9 |$ E5 }: mWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
: E7 _, d$ D2 P. `/ r& F{n,N}
7 F, ~2 q; n1 ]; o  D9 GMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
Will match “nerd” and “neerd”

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

s/pattern_to_match/pattern_to_substitute/

- g- Y; C+ F, D6 h9 }3 Y# I
1 P1 N% @5 X7 {7 f7 n5 fTable C: Regular expression anchors
-------------
. m2 j3 e8 V0 T1 C+ d4 ?操作
解释
例子
结果
---------------
^
0 J) f/ b; Q$ L8 i5 a  P$ }Match at the beginning of a line
s/^/blah /
Inserts “blah “ at the beginning of the line
- \" O5 ?9 z( k---------------
$
Match at the end of a line
) l" n# j% e" O/ d9 j( hs/$/ blah/
Inserts “ blah” at the end of the line
---------------
\<
# x7 H: @% s' p1 ~Match at the beginning of a word
s/\Inserts “blah” at the beginning of the word
2 n" S& V) g* |: o" h: ]2 D4 V2 @
- c' ^( _( N/ Jegrep “\Matches “blahfield”, etc.
------------------
\>
# B2 k/ A" s, m7 f) f# T3 O6 KMatch at the end of a word
# Q+ f9 B% l* ?/ E& [. ^s/\>/blah/
4 R4 P. \1 P; z$ R/ s$ {  X, zInserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
: ~' W. c1 Z- A: G---------------
\b
Match at the beginning or end of a word
  ]! w0 a, z. G" R) [: segrep “\bblah” sample.txt
& j+ i* ?7 g4 \1 I  ?  T  P. A: rMatches “blahcake” and “countblah”
  r8 H8 H6 W0 r0 f8 B/ w0 X-----------------
' c5 \$ B, A3 J4 e\B
4 E5 e3 V7 T- {  L: ]1 l; jMatch in the middle of a word
# e! J& H. L$ H/ fegrep “\Bblah” sample.txt
, ?' N0 A0 `6 V+ cMatches “sublahper”, etc.
; x! E/ k; z4 T5 L2 `, w
0 c( N- P% z4 V) e! z- f1 S间隔

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

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

" n7 c. m1 c3 j$ S: V间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

' j9 b% ^# U! Wegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

; s$ G, O! @' k3 m3 _8 P第四部分：
. J( T% R2 g& O) h) \9 ~7 V+ s----------------
1 H$ z4 r8 L6 D4 B( N; f  U* A: j一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
' j. U4 F1 M6 C2 s
^ (carat)
$ Y- @  l" r8 E/ q. B' E. (period)
1 n+ N9 m+ p; [5 l/ s  I[ (left bracket}
$ (dollar sign)
2 q: u7 t# a- X( (left parenthesis)
) (right parenthesis)
' ~) u' Z4 j# ?: {| (pipe)
* (asterisk)
, |) m  Z8 `) r% ~+ (plus symbol)
# O+ R" r+ y  V$ F% ]4 l& ~3 N- A' `9 O- n? (question mark)
  z; v* `3 _; W# t( T{ (left curly bracket, or left brace)
- ~2 N& V/ i8 A$ O9 g" t  z; J\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

6 l# {* j5 |4 c' d( ?' Peregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
- w/ V+ z" n8 ^; z) i  x
总结
$ ^# W( |1 U5 O  B在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
5 n/ h6 e4 t! [6 P
另外一篇文章
----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
类和方法
, ?) M1 s! w8 [. v9 S# y: i9 L
2 {2 ~$ m, ]. R4 Z* y下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类

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

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
, V" L3 n; g$ j  F
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
/ Y; p8 o& y' [+ H% x! O" n
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
2 ?( A/ q3 Q$ V% Q: J! f
/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;
) ?7 H2 j0 ?, F* @
public class Splitter {
public static void main(String[] args) throws Exception {
2 S. y& @9 O* Y7 k2 q// Create a pattern to match breaks
' `3 ~* i6 y4 H' s( o; a/ UPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
String[] result =
2 z4 b# m2 q4 F: E, \1 T% W( h   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
/ b7 X* x8 i5 ]  G, B$ Z  Y# m}
. l+ t  B$ I3 ^9 ^  b* p}
3 z6 R# g3 r' y/ {
2 t: m. ?+ Y! b+ R) z  |Matcher类
0 B- U* o8 H: _. P3 Z0 ^# N
( Z9 P) }3 r: p. A- `Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

4 M4 Q- U! H  F; V; R2 i, b通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
# g# i& [- s  q0 d& Q5 S% _: u" sfind方法将扫描输入序列，寻找下一个与模式匹配的地方。

# r, a& B, A: Z. X" q这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
5 u! C6 K) Y# Q5 c
这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
' U1 g; j* [0 [+ s
: O5 @8 v6 V% r) c8 LappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

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

& x+ m- L/ x, \% ?9 C; v2 E/ |8 GCharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
# ^+ z7 q: ^. }3 A. O' }
" `6 F+ R* _2 u+ k% a5 [Regex情景范例

) d8 M5 [  H! Y- W/ d以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

  R4 T6 d/ |. Z. z8 m7 \( r& U" P0 p简单的单词替换
6 U. }1 s! ~' z8 c3 t
/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
, i- S! M- g7 u! u& N- P*/
import java.util.regex.*;
/ y) x$ f3 j  k) J% Z- u  ~
public class Replacement {
public static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
* r; t( X$ R+ GMatcher m = p.matcher("one cat," +
- n; |. N5 h! C/ e1 j4 i5 c     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
2 {# e! E( U$ a// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
m.appendTail(sb);
& d; j# `5 R! P; i5 v7 V! ^System.out.println(sb.toString());
9 ^) g+ D: h# O8 v}
}
2 E% p* w6 E( P. _7 B) `
电子邮件确认

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

/ W+ [; Q( x* z( e  g! j/*
* Checks for invalid characters
0 M) Y6 l: k  G* in email addresses
) a. M2 u" {9 m  ?3 ]! r0 s! \*/
# V! F: n4 t5 X. s0 @) W1 \8 q' H2 gpublic class EmailValidation {
public static void main(String[] args)
9 _, [. @6 D0 |! F) Q) v           throws Exception {
           
+ C) }; r. u7 Z0 u. r. ~String input = "@sun.com";
//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
/ S! `: n) u1 p& x" Y$ gSystem.err.println("Email addresses don't start" +
         " with dots or @ signs.");
8 y; \/ o  a2 w//Checks for email addresses that start with
. k; Q2 R# k- h, w2 L//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
# i" b: o8 Y2 [m = p.matcher(input);
/ \: K2 r) B$ y4 R2 ^, wif (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
( `" O& b% I9 s3 g( |% Z0 f}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
3 p; {  B1 E5 T6 `m = p.matcher(input);
StringBuffer sb = new StringBuffer();
! V) Z7 d6 ]9 R( n8 t/ ?boolean result = m.find();
boolean deletedIllegalChars = false;

. Y6 M% \/ J6 O+ \4 I( C) f# N- y' cwhile(result) {
9 r; h0 Y" n* A2 Z( A$ ?( x( WdeletedIllegalChars = true;
m.appendReplacement(sb, "");
, q/ ]1 V! c+ }* Cresult = m.find();
}
# k) o, I, E' `
4 s8 S) L/ c% Y// Add the last segment of input to the new String
1 Z/ o) U* f# q9 }; M# t1 y) q9 `$ bm.appendTail(sb);
  P0 d: ~- X; d* _. Z
$ s. M& X, h* C: n* D" k# dinput = sb.toString();

if (deletedIllegalChars) {
0 H8 d' M- j! k8 |0 dSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
6 W% x! j. U* O}
}
* P  l9 A9 [. s" T2 m5 }}
* b! a0 k3 G9 I( n( Y# s  `
从文件中删除控制字符
, m4 e: s) X4 M; n* I  K
8 P; D4 v; ]+ F8 h/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;

. G7 o( q" k1 E; B8 ]0 ppublic class Control {
public static void main(String[] args)
           throws Exception {
           
//Create a file object with the file name
/ H2 K4 s9 S8 ]" h3 D1 {//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
" p0 u; i6 ?( mFileInputStream fis =
* l. Q# k& ^! `9 t       new FileInputStream(fin);
7 a+ p+ C3 B, p4 DFileOutputStream fos =
       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
4 F1 k8 A' u( d) n1 Y( J: k     new InputStreamReader(fis));
) m- }# B8 @1 ]$ ^( ~, QBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
$ b; ?/ l  B" }9 V. i
// The pattern matches control characters
& D8 |9 f" i7 {" K2 kPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
3 [8 c" P" t4 V& `String aLine = null;
1 H8 u: q$ ]+ P* zwhile((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
! _. v- X7 ^" D3 ~//string.
String result = m.replaceAll("");
8 K3 `( b* V( x- E* G4 F, J' gout.write(result);
out.newLine();
2 S  W7 b+ ?$ P5 `' A7 p}
5 A7 P6 c+ s, }3 Z4 b3 u1 A' b. ^in.close();
out.close();
# a- Y( h1 Y0 L7 p6 A* Z}
, \( L9 A/ O3 i6 M}
6 E1 `6 m& s. f3 E9 R' s
文件查找
/ q7 k$ F# ~2 u2 M( }
/ t5 n) T! }: p1 ~/*
* Prints out the comments found in a .java file.
: G) s% |' ?. v" r- M$ [7 y6 |0 |*/
import java.util.regex.*;
0 T; j- o$ L: b1 E+ }7 f" X" fimport java.io.*;
; [; w1 S' d. s" p) F. G5 Oimport java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
3 K0 ]3 i( U  o
public class CharBufferExample {
& _$ F9 ~. h1 B: Ppublic static void main(String[] args) throws Exception {
8 G) R" }. n4 W; D9 K4 b0 j// Create a pattern to match comments
Pattern p =
. \% v2 d1 o' C- v6 w5 o2 iPattern.compile("//.*$", Pattern.MULTILINE);
; @) n7 t+ y0 e
$ C) ]  h6 B# L) ~3 b// Get a Channel for the source file
: V8 Y0 D6 Q" M4 c$ \2 N+ }- X" BFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
. c2 S6 Q- ?4 {# N  M. oFileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
4 V: D/ Y" d" t) Z* i6 fwhile (m.find())
System.out.println("Found comment: "+m.group());
}
* c$ j; g# U: f}

* b& {0 ]2 C7 \1 R; `* T! p结论
2 b' c- L$ o& V) w; c5 C: v现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
+ I) @3 t& h" C+ C7 _  x+ Y, {3 ~
9 ^2 z: I( y' G, d( Y& k  qJDK1.4之正規表示式
written by william chen(06/19/2002)

--------------------------------------------------------------------------------
6 e( b' K3 }7 X: W4 b, I
什麼是正規表示式呢(Reqular Expressions)

1 K! x( q8 r9 O, M就是針對檔案、字串，透過一種很特別的表示式來作search與replace

7 W# T8 ~- t) M因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
: A- R  s8 e- H
3 U- }3 }) h' U3 H. v, A% a* F, u所以發展出一種特殊的命令叫做正規表示式

( ^( d: R# Z/ ]( V我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

& n9 b$ h/ W; `若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
+ r6 u$ D* m+ g& H" ?+ ]. A
& A" Z: r' [" e: L% C3 L"." 代表任何字元

8 J7 R, J' F/ g0 b$ @正規式 原字串 符合之字串
. ab a
.. abc ab
- }6 y* @& ~  N3 b/ }6 E+ z2 P
"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
9 z, j! a8 Q- I3 C
0 p; M9 `/ G0 }0 x正規式 原字串 符合之字串
+ ab ab
* abc abc
8 i- s, C' {) ]/ H- y
"( )"群組
" K" r& y/ p  D
0 e+ Q" o- K6 r( n7 M8 k正規式 原字串 符合之字串
(ab)* aabab abab

字元類
* y5 N$ m$ e/ N  I2 t
: t6 K  ]; [! B" ~& v1 i正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
/ r* F! I5 e- o1 k  u: n[a-d]* abcdefgh abab

( @6 |6 M4 [% i0 v: ~
0 b8 v$ E) \) \2 t- g簡式

\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
' z! z) D" p  b" _- [1 U2 s8 m\s 等於 [ \t\n\x0B\f\r] 空白字元
% V1 v% f0 y! \\S 等於 [^ \t\n\x0B\f\r] 非空白字元
; ?7 T) `7 t! a/ |/ `5 c0 @\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

* ?5 u# P% ~5 _9 ~每一行的開頭或結尾

0 q8 @. k' Z( e' y- O^ 表示每行的開頭
$ 表示每行的結尾
4 x* r) }5 w+ s+ x! x
--------------------------------------------------------------------------------
9 d3 Q7 A" O/ o; r* k7 c; U
正規表示式 java.util.regex 相關的類別
' _7 }+ C" M6 W
Pattern—正規表示式的類別
/ L+ ^: ?6 ]' t1 PMatcher—經過正規化的結果
# J# o0 q' ?! F- z% e4 \PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
& |9 X0 \# ]& e
5 f* j9 ]: r( K範例1: 將字串中所有符合"<"的字元取代成"lt;"
( o' P" ]+ q% q& C/ I9 X
* S0 M2 M6 @3 pimport java.io.*;
& m8 O7 G+ @9 H: i, {: Uimport java.util.regex.*;
/**
& p3 ?6 ?* n# y* 將字串中所有符合"<"的字元取代成"lt;"
: Z0 _0 ]+ N% H) h, k# e* a- h*/
public static void replace01(){
  H9 [3 {% v1 K2 R// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
2 I; R- S& L6 [& s; |Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
  O! y6 u& d, r; c1 K! O% ctry{
( `( }8 @3 r) Q6 _  P1 nwhile (true) {
7 V7 {2 s4 U+ \& WString line = br.readLine();
2 C7 U8 ~+ y3 t% x' `  S// Null line means input is exhausted
& o& W" ]% f& W5 k- M" X3 Z1 j/ Aif (line==null)
( Z4 V$ b" J. g& `. w+ W0 u% q) _break;
Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
. s4 M1 J. U& I. Z9 z' ySystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
' w1 c8 F- L9 c, U}
& [# q1 \2 g% D9 Q* A}catch(Exception ex){ex.printStackTrace();};
}

7 @4 R2 L0 [) N/ z! V7 x; _範例2:

import java.io.*;
# U- [0 }' q, X" n! U+ mimport java.util.regex.*;
/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
*/
# O2 f" {* G+ Fpublic static void search01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
8 q8 [$ C0 z- y5 o% t- ~) HBufferedReader br = new BufferedReader( r );
# y- ?5 \6 S  K9 E7 _$ ]. _Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
2 v) |$ N/ C/ |( R  s  P0 Jtry{
while (true) {
String line = br.readLine();
  [9 r% k! k' v# `$ S) VString words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
4 C" J0 f: l* fint longest=-1;
int longestLength=0;
. Q# V% Z. A( O3 [. m; _  Qfor (int i=0; iSystem.out.println("分段:" + words );
; B7 v$ f. [2 E7 q* s; aif (words.length() > longestLength) {
longest = i;
longestLength = words.length();
}
/ Z4 X6 {! H8 C6 t}
8 m5 z/ M% L. ZSystem.out.println( "長度最長為:" + words[longest] );
}
- ^. p/ F1 o, s}catch(Exception ex){ex.printStackTrace();};
}

/ {* z" c0 [1 b4 g+ h2 }# ]7 |  q--------------------------------------------------------------------------------
; o  x' l& E. S: D- E$ y3 h1 i
其他的正規語法
5 H0 s& O2 k8 T' m9 O
/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水