关于正则表达式---ZT

Longe

第一部分：
+ v7 \" b% B  ]+ X; ^% a% {& r-----------------
, R) ?' Q; {3 v9 y; q正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
9 O' e/ ?) Q2 E3 N: v) N- h6 V
支持多种平台

- C6 n8 A7 F" c2 n0 G( C8 l/ l$ u8 `
) e2 R! s  p, }4 S5 \8 {正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

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

, q  z& ?. Q9 C7 A! T% Q许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
7 @+ ?# x. C! ~; U! {
7 j1 h7 ]  L. a9 q* ]$ C比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
! A3 j/ Q4 @( X4 B3 q* H
" k/ {- g) K& A正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
8 k. G, o- ~3 G' S$ i2 P----------------------
字符匹配
3 G: j6 M  [" ~& F8 H
. x7 R. k2 ^/ V$ X/ E正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

每一个表达式都包含需要查找的指令，如表A所示。
7 R7 g# k  ]4 s4 I! y
" M. N0 R0 p* l( z' UTable A: Character-matching regular expressions
格式说明：
3 _2 n! D4 t3 F, T---------------
操作：
解释：
; A0 V5 k. q% |6 b' u例子：
: V/ ?' R) u; r- Y$ ?结果：
----------------
.
Match any one character
grep .ord sample.txt
3 V; V4 b% O. I. ~) a  C. VWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
  I6 _3 j& R. u/ ]* t6 B[ ]
Match any one character listed between the brackets
  ~; }; T+ s# Z0 Xgrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
* A) |* [! w! X( p---------------------
8 K5 ?; k) b0 G/ O2 Z& {0 [[^ ]
Match any one character not listed between the brackets

$ \. N& i4 _4 a2 V, ggrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
# t5 R& l3 {' A2 C
grep [a-zA-Z]ord sample.txt
. Q/ _/ U) h! sWill match “aord”, “bord”, “Aord”, “Bord”, etc.
2 `5 U4 c" r% J* }2 p+ `1 J
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

  ~! S' a; ^2 K* J4 [. X重复操作符
) v8 y( U7 v$ O8 h0 R# p重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

  Q: ?  Q3 [7 j( s2 a2 @3 g6 U. ]Table B: Regular expression repetition operators
格式说明：
! |( S% r% |  i1 B, x* M9 p7 [& \5 V---------------
操作：
3 U$ \" q0 }, b% W% U: S解释：
# `2 \5 e% F" H9 V9 D例子：
结果：
3 w& r) ~1 G9 Y) o----------------
- m! U" K: @/ U: C3 g5 b" f?
6 @+ [2 w  a, Q5 m" [Match any character one time, if it exists
6 i7 P# v6 f# m  t# j- zegrep “?erd” sample.txt
9 G2 f* u2 W: p; W* A2 x: gWill match “berd”, “herd”, etc. and “erd”
------------------
*
7 [$ U. w+ _  l1 q3 ^3 G8 y+ y, ZMatch declared element multiple times, if it exists
egrep “n.*rd” sample.txt
2 n6 s' E( o& X, Z; zWill match “nerd”, “nrd”, “neard”, etc.
-------------------
+
Match declared element one or more times
7 n6 W. E+ y6 N( ]7 r9 }* b6 e& Megrep “[n]+erd” sample.txt
6 s9 @: I; f- y, n6 r0 w% CWill match “nerd”, “nnerd”, etc., but not “erd”
% U$ ^) t+ ~7 D3 W- q$ F--------------------
) t5 e3 [) p' H* G+ m2 ?+ Z7 M6 X2 j, Q/ }{n}
  P. p% V6 k7 `- uMatch declared element exactly n times
% |6 Y, c* ]1 ?. U: tegrep “[a-z]{2}erd” sample.txt
" q! m# K2 O* s' \* IWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
# ?& `5 K' u) k{n,}
Match declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
3 C4 Z; c- d) G------------------------
+ f8 i+ T# N, g& r3 s{n,N}
Match 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”

( N' h& T# P% T* ?  d5 T第三部分：
; _% z' R: F8 C7 t2 T$ @----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
. z( C" x/ e/ K) [4 M; c1 d: F
s/pattern_to_match/pattern_to_substitute/

  P" Z  C8 u4 o2 W! J* g
- @$ ?+ @7 t0 s; \Table C: Regular expression anchors
-------------
操作
解释
( M- _7 d2 q3 N# u; j: Y例子
& h1 g& K6 K; ]+ o2 G# W" a结果
* v3 L! u# g  E9 c0 \---------------
  L0 w! [4 M& F1 Q^
/ w& O, P1 i  k0 ^* R* T+ jMatch at the beginning of a line
: K! e) s, O- O% W/ m9 Q% n2 k8 qs/^/blah /
$ F4 \7 E4 P6 IInserts “blah “ at the beginning of the line
---------------
$
0 R5 s& @9 I: a: p+ \3 S  ^Match at the end of a line
) h' j8 e% p6 G# h6 z) Js/$/ blah/
Inserts “ blah” at the end of the line
---------------
0 }" w4 y) f; U7 y\<
& j& I' r( `, s0 YMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
------------------
) {! ?" v* x. a, }! |\>
Match at the end of a word
) s; ~: K2 r4 ~, \6 s& x8 p8 |* O$ Hs/\>/blah/
Inserts “blah” at the end of the word
- \' M4 }: M1 Y& U; p
5 {% _2 n2 F6 D* eegrep “\>blah” sample.txt
8 B( ~" X; K8 @  S; tMatches “soupblah”, etc.
/ V0 k6 j" v/ R3 \; Z: c, O---------------
\b
, l' `' Q3 @) lMatch at the beginning or end of a word
egrep “\bblah” sample.txt
5 h4 K( e0 |7 \6 u3 h+ nMatches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
, S! S  o3 i3 |. i) regrep “\Bblah” sample.txt
Matches “sublahper”, etc.

间隔
4 E( b# i: {& }! L. R0 S4 `% U
Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

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

" ?; @5 g; j+ `* \$ X间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
3 t! l8 O5 a0 ?! [+ K' }0 ]
" A, q- ?; j+ w, {! U7 p第四部分：
----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

( d1 p' Q5 h- H0 T4 U3 }- {^ (carat)
. (period)
2 h# r0 h7 j: t$ `3 u[ (left bracket}
& y/ [/ |; ^7 z& k# l$ (dollar sign)
: J" B4 @& c! R1 m' p) M( (left parenthesis)
) (right parenthesis)
# @# I- Q% `9 i: F| (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
  t$ K' R' D( Y; I$ n: C. u5 k{ (left curly bracket, or left brace)
4 A: Q! e; ^9 N/ D( i8 O\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
0 u, \/ ~7 y6 @/ }8 Q; @
' a. I2 ~4 C+ b+ a8 Y0 p. T/ Zeregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
; z' A& Q6 A, O) F9 K5 P% K
& Z- I9 Q1 k5 S; j  ?3 R0 G' `. I你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
& g+ X  ~) a( K  @- l
总结
1 b. V+ b) |, K. p% l* f+ t4 \9 I在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。

0 W, a( b6 H. v8 X0 X2 T' {$ F$ O! L另外一篇文章
----------------------------------------
正则表达式和Java编程语言
" \+ w+ K. C" _! f4 S* g-----------------------------------------
类和方法

4 }/ W0 T  Z% _5 O5 N9 h下面的类根据正则表达式指定的模式，与字符序列进行匹配。

* R7 B4 o* {) H, p" }Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
" i8 T+ {) h/ C2 n6 i# u
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

6 _. P( x4 q2 }: R% Y) D9 U5 k. Ksplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

% r, v' r7 o( J! Z" _/ l  d/*
  H9 |% {5 W, W& c- O$ A- \* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
  z8 a4 g; [$ D4 s- }; p- {/ [  e9 v) @import java.util.regex.*;

public class Splitter {
" ~' p' A% h" H, R, h/ c: kpublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
. d8 B7 y' u: r6 xPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
6 u" l6 K/ x2 d# z( OString[] result =
! y; ^9 E' v4 _3 R" K7 u' `   p.split("one,two, three four , five");
% X6 y* M8 g6 n7 cfor (int i=0; iSystem.out.println(result);
}
% w' c$ V* Q8 T3 c}
5 q; s) Q7 w0 i1 I# W
Matcher类

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

* [  F- _$ I+ I2 y通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
2 L6 b' @8 s1 O/ U" @
/ W% g  d1 C; ]. P! d0 B这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
: g5 b: i8 g9 P2 k
. j1 X+ Q( T) A" z$ q这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
8 p7 d+ p, r9 t6 M
! B# u! y* [8 w; nappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
' a2 A8 [" i+ `: x* o, M# r1 f4 K  c
5 m" R& {8 Y8 A' Q( }3 M4 @例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

CharSequence接口
: [$ f3 I% @6 k: g5 c
5 `" t1 l1 C+ x2 HCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

Regex情景范例

6 Y9 @3 P. a; q" H( ~, {以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

简单的单词替换

/*
! L" P) B/ e+ S5 F3 {, u9 D* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
*/
6 f& {& j; |; f; b, Ximport java.util.regex.*;

public class Replacement {
5 C2 o" o$ T5 O; X$ P8 a5 v  Fpublic 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
& F  n4 j% X/ |: u& [( ~0 n6 m% D$ X+ a& QMatcher m = p.matcher("one cat," +
     " two cats in the yard");
$ S3 q, x1 J: K2 f' I" {3 T# m. bStringBuffer sb = new StringBuffer();
boolean result = m.find();
* \+ j( s1 g4 N// Loop through and create a new String
, @0 n% ^) I: |6 ]& a9 e( G// with the replacements
$ G) e+ o; @5 b1 R, M8 {while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
- @# E: o9 M, t" i- X+ l. \m.appendTail(sb);
System.out.println(sb.toString());
- h, f. e; a$ `9 ?; b}
}
& i1 j: T! z( f2 o8 }
; M! \0 L  G, S1 ?/ [电子邮件确认
5 l, P5 {& T& y! P$ `3 z
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
6 x* w8 I( G2 m5 b  A, g
) x5 G- o9 A9 w  T& I% }5 a/*
: i5 |" \% d: |* Checks for invalid characters
* in email addresses
*/
( |! o& F: J% q. h6 P* Zpublic class EmailValidation {
  N. C2 f- \0 P4 c' P- n+ ]; Xpublic static void main(String[] args)
! R7 e+ v, }2 P1 u           throws Exception {
           
String input = "@sun.com";
  H5 X7 d3 o# ]. @; ~//Checks for email addresses starting with
) X! Y4 i5 \% d% ?$ x6 i//inappropriate symbols like dots or @ signs.
6 M: K9 ]" m5 [) T& XPattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
9 l4 C# T9 W1 ]& v2 D! @System.err.println("Email addresses don't start" +
) l7 x2 I# \1 n* j         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
8 j" P) e. ?7 r6 v2 Z+ @) Dm = 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);
* m- j$ `: q! L* FStringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
6 S) Q+ K6 f. Y8 m5 F+ }3 Q8 e
! p) z* S& u" Q8 l, {3 P; \' [( ~while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}
) x6 g/ ?4 j+ j
// Add the last segment of input to the new String
m.appendTail(sb);
( ~4 j, x$ \- E7 R" k, L4 ^. r* k5 M
input = sb.toString();

if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
# D, m4 [! V; q& K: H       " , such as spaces or commas.");
}
2 _4 E8 y  s7 f9 z7 P1 Y8 M}
3 U; O3 i# t  d8 G}
3 I' P4 G# E" }7 S# v
从文件中删除控制字符

7 H, o" {8 ]+ L' a0 i/* This class removes control characters from a named
* file.
*/
9 u& {, y# r: H  M: p. aimport java.util.regex.*;
! N1 N8 c  s5 Pimport java.io.*;
- ]- }7 l  \) n- X# n. X; e
public class Control {
9 j, T; J! N5 ~8 Gpublic static void main(String[] args)
* P2 I. e5 W+ a# D% P' p           throws Exception {
' L# {( D- _/ z9 j1 v           
//Create a file object with the file name
. Z0 Q2 ^1 y7 b0 {6 e+ z- X* q//in the argument:
File fin = new File("fileName1");
File fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
( D7 \! J% r8 F- _1 s3 B, V. K' oFileOutputStream fos =
$ {$ a- w% T- ?6 i7 ^9 \; H- \       new FileOutputStream(fout);

BufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
4 L, }6 G( x# W' N" `BufferedWriter out = new BufferedWriter(
$ [+ w& r; {9 W* x8 P  \     new OutputStreamWriter(fos));

// The pattern matches control characters
. u- U3 [8 K* k2 L3 V, {Pattern p = Pattern.compile("{cntrl}");
! _1 y7 ?/ j% k3 x7 L$ ZMatcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
9 u# x5 ?2 h) t* l6 [/ m5 lm.reset(aLine);
  T$ h  d. o' m7 e# J//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
}
- M/ v! K" ^' H, r3 \in.close();
out.close();
}
}

! K# M* P, t$ C2 W4 E文件查找

/*
* Prints out the comments found in a .java file.
! I( f2 i9 h1 W3 ]*/
import java.util.regex.*;
import java.io.*;
7 A/ b- K/ K' simport java.nio.*;
& z. j$ a( Q% D. k/ pimport java.nio.charset.*;
import java.nio.channels.*;
6 z# u2 u& L# K; \2 j
public class CharBufferExample {
3 {7 E4 R0 ]5 G, _) g& }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
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
3 C5 k7 U+ B( K3 c+ p8 ?
( S, S7 @! F$ F// Get a CharBuffer from the source file
5 @& n% N/ L( N* E+ xByteBuffer bb =
, f! ]! U% a( T8 T1 p7 K7 d9 ~- z5 jfc.map(FileChannel.MAP_RO, 0, (int)fc.size());
8 l9 M$ t- N- B) gCharset cs = Charset.forName("8859_1");
) _# L( y9 e5 @; F& J5 m# n8 a  TCharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);

// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
" f, R  C& g5 W, E  s( S4 G8 X}
8 G3 ~! y( n  ?
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
% w0 n2 ~& X; a$ E/ `5 J4 |written by william chen(06/19/2002)

$ H2 p- S$ T( d! _) ^--------------------------------------------------------------------------------

4 C& F/ }, s: @( @+ ?什麼是正規表示式呢(Reqular Expressions)
  P$ O$ U4 |, d  s
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
, Z* d% u" H5 I8 {/ N% \2 P
% g4 g, p" `5 f; H因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
$ V0 M# A7 X) `  y) @0 H7 g6 I
. k5 z2 j# b3 A/ I& P2 w2 m* D所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
; Y0 u# h3 K; f. q因此jdk1.4提供了一組正規表示式的package供大家使用
5 `! C: Z, k2 w
! e7 k+ F: v+ z# ^若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
$ y5 B# `" A, a' _4 S2 }+ ~7 A
. l# n0 J% l3 p' P; q剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
1 [9 J' [4 R" i" q( }# w
"." 代表任何字元

% T0 V  Z) A. K6 F0 t: B( b) l3 c4 X正規式 原字串 符合之字串
. ab a
.. abc ab

"+" 代表一個或以個以上的字元
* _# x9 B; S* J( q"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
+ ab ab
* abc abc

) ~* w9 F4 a6 W' W6 S; {2 Y8 u"( )"群組
8 D" c. [+ z9 B3 b+ {) F5 D  O5 a
! v' W- f6 H* S: e' [正規式 原字串 符合之字串
(ab)* aabab abab

( F8 M) Z. Z8 U: F字元類

正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
1 e" `8 f, s( c- C* {[^a-d]* abe0 e0
+ W2 l' |5 V: S, I4 P1 t[a-d]* abcdefgh abab
& J5 ^" p- x& Z
- m. G, C1 f2 {3 n
& w2 g: p+ H: F2 ^) ^  V4 R% R簡式
/ M: N5 F! T' q9 P4 h! l2 h
  K4 u1 X) z# W/ Z9 f\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
, `2 K8 v, `4 r. o\S 等於 [^ \t\n\x0B\f\r] 非空白字元
! R- R. W9 N9 o  Q% O! D\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
! }( O, u5 P- V* z3 A
* G  Y: Z. `; G, s. Y每一行的開頭或結尾
( W( I+ T' ~5 J5 }- N) _
^ 表示每行的開頭
# d9 c4 X7 V6 Y* I0 v$ V$ 表示每行的結尾
* f, G( ?0 R3 U
1 m6 k0 }* I# u1 Y5 L4 v--------------------------------------------------------------------------------

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

Pattern—正規表示式的類別
; L- I8 O4 |( }0 r, J2 H. X% BMatcher—經過正規化的結果
: j/ I5 J8 L8 {5 F/ U5 NPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

" e' r" `" a4 ?範例1: 將字串中所有符合"<"的字元取代成"lt;"
$ Z3 _# P! @% O& G% A9 }# n* t
. {: T& v& j" E4 r4 Rimport java.io.*;
import java.util.regex.*;
/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
' S7 D9 ?1 G  ?+ `public static void replace01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
) ]# G: C& e/ h7 DBufferedReader br = new BufferedReader( r );
$ k6 d7 `7 H" N0 GPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
$ B$ F( U0 X) ~% SString line = br.readLine();
// Null line means input is exhausted
if (line==null)
break;
* ?  s9 w& H1 L9 M6 Q/ IMatcher a = pattern.matcher(line);
  f+ ^' ~* y; _& o! `  qwhile(a.find()){
2 ?1 d& @/ p! V1 \: l: uSystem.out.println("搜尋到的字元是" + a.group());
% g  B0 x# ~! n# C  Y0 G}
, x  x" T4 V0 RSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
* J" ^% Z* H) T- N5 g7 T1 T8 B- D}
}catch(Exception ex){ex.printStackTrace();};
0 f% ^, `% T- o4 D}

9 e: b9 p& X/ B4 L7 {範例2:
- M# e; p( ?5 |1 t! B  v$ r
import java.io.*;
# {) R& v1 G; f5 W% e+ K% himport java.util.regex.*;
/**
9 O) ]+ F1 _9 m* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
: p/ Y% l8 d7 W; G*/
public static void search01(){
// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
& S- u2 p- Z) s0 b- rPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
String line = br.readLine();
6 M( C7 A0 V2 G: G8 P' X/ W' v$ PString words[] = pattern.split(line);
// Null line means input is exhausted
7 ~* W' [7 t; y* j" Y+ q& xif (line==null)
2 c  ^0 ^- C; d8 Ubreak;
3 C2 j0 F% u0 ^, x5 z// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
  i. l& M' S$ k; D1 Efor (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
" l. k) L& o; \/ ?" q7 hlongest = i;
1 B; y# M1 ^+ S3 X) llongestLength = words.length();
9 j0 a; U1 k) k$ I9 a% T}
& r: w; D/ T! h8 o}
System.out.println( "長度最長為:" + words[longest] );
& p+ |0 w8 q8 A0 _2 R3 K}
}catch(Exception ex){ex.printStackTrace();};
+ B& F: X; a0 i" m}
& ^4 l# x$ \1 ?2 u) w" [% t
; \4 C6 R  Q" Z3 `" I: C3 I--------------------------------------------------------------------------------

) a4 M0 I: {/ z6 p其他的正規語法
( P# Y7 H$ C2 @) B6 [
/^\s* # 忽略每行開始的空白字元
( V& [1 d! R) f& b(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水