关于正则表达式---ZT

Longe

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

7 f3 @/ d4 {3 M支持多种平台
% S0 e6 e! B2 n5 ^# Y7 M4 {! Q' n
7 y8 f& Q2 {3 H. Y& |
正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
8 j2 |9 y( u0 V+ k+ s, {
) k7 V0 k$ |1 H4 H# n' `% f5 a1 P正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
; U1 i" D* `0 ~* V8 i2 c3 B$ J
0 S9 M1 J; L" K8 T$ f9 c许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。
) P4 b- m! e3 {
/ F/ }7 K2 C% b- H# }比你想象的还要普通
  j/ P2 o9 L2 Z$ e2 D( V1 D随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
4 b  @2 D7 O5 A' o) W/ j4 \
正则表达式101
3 m8 S) C$ }. H4 g很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
5 G/ J+ z/ o# l$ M3 A( h----------------------
字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
7 Y  W6 q$ G5 t( l
每一个表达式都包含需要查找的指令，如表A所示。
6 l5 @8 z6 ^4 l1 M; o5 R
: I) y/ H0 [; U0 D/ Y' bTable A: Character-matching regular expressions
% H9 K- Z# q% u7 a( Y0 C9 p; \: }格式说明：
---------------
9 ]/ I* e! X$ ^$ v) _+ e操作：
; Y% Y* y. k  y+ S0 n0 j8 |, O8 M& D解释：
# [" a7 @$ M* @9 F4 E5 M# I# a: U例子：
结果：
----------------
2 a/ t# v) u/ P- t2 i3 X. q.
+ |5 A' K0 t- HMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
. r; Q! l+ Z9 q-----------------
[ ]
Match any one character listed between the brackets
+ r2 V# M' U2 Vgrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
, \. a+ ?8 @5 G+ U0 \3 S) [8 |[^ ]
Match any one character not listed between the brackets
. \3 T) \. @3 b- ]$ \, h
: r6 d" e3 Z- ^) x3 Xgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”

: ^' o7 v3 h" h4 N" w/ }grep [a-zA-Z]ord sample.txt
4 X1 c5 A% p4 n- IWill match “aord”, “bord”, “Aord”, “Bord”, etc.

0 t- G# l7 o+ f7 T8 B  q% agrep [^0-9]ord sample.txt
' m! n" R! f) K' `Will match “Aord”, “aord”, etc. but not “2ord”, etc.
1 v/ M; ~5 Y8 D. k9 N" Z3 `
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
格式说明：
---------------
操作：
' A4 l0 A8 p; r( Y4 ^. o, ~解释：
; R  g3 _6 D5 L/ b例子：
" D' D' y7 P8 N- J# d& e( M结果：
----------------
?
3 s: R" Z$ H, C' p6 U" qMatch any character one time, if it exists
9 d% n) V  S: `; @4 cegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
! f# I( O4 e+ b7 K0 _' x2 N------------------
*
Match declared element multiple times, if it exists
7 ]' Y. ^. B+ D( ?+ Regrep “n.*rd” sample.txt
3 p4 S) g$ [" ~; e/ V# p1 r6 K9 dWill match “nerd”, “nrd”, “neard”, etc.
% H/ \0 ]3 R8 m2 B) |-------------------
+
Match declared element one or more times
egrep “[n]+erd” sample.txt
4 ^* i* a' w1 T) iWill match “nerd”, “nnerd”, etc., but not “erd”
% ^9 M1 j6 ]* p6 A  t( S& b' q--------------------
4 y5 F6 i9 h4 o8 h- W. ?0 n5 a{n}
Match declared element exactly n times
/ q# N) |  B1 Q9 Q9 h1 _. e! iegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
' I9 W' H: v& H% g# y0 oMatch declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
5 {) u. s$ ~- I8 S+ J------------------------
{n,N}
$ c* \7 W& B7 ]+ H, L8 R$ {1 U$ PMatch declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
/ _! P( ]6 G* d3 ^, F6 vWill match “nerd” and “neerd”

) d0 G/ `( T( i4 u' G* j第三部分：
& M% s  T' i& M+ v----------------
0 V; ?6 K5 F* J; m4 {% U锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：

s/pattern_to_match/pattern_to_substitute/

+ D' x5 V. t# r* A* ~4 X
Table C: Regular expression anchors
& H9 \# Y6 }" v& G: `# G) i-------------
操作
" A! n7 L" e. k9 B. |! e解释
例子
结果
6 T4 U/ ]& M9 W1 i" [5 |( m/ m---------------
/ F; h) F1 v1 g- U  ]4 A^
Match at the beginning of a line
s/^/blah /
% t6 N0 S, s. y+ v' a4 yInserts “blah “ at the beginning of the line
8 c4 e9 H; l+ Z# s1 K! t---------------
$
! R5 }7 N9 I/ l2 _Match at the end of a line
- W) ?8 R* t' Z0 A, us/$/ blah/
Inserts “ blah” at the end of the line
---------------
/ e" F$ M* N2 d; z" |. v5 n\<
Match at the beginning of a word
' z% n1 {- \8 Z. Ms/\Inserts “blah” at the beginning of the word

: b; s6 R% b9 K/ Segrep “\Matches “blahfield”, etc.
------------------
& i# S0 B1 b, Q2 v\>
Match at the end of a word
s/\>/blah/
0 F2 F! g# M$ n2 k4 l0 CInserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
, W! R* O& f6 y) @; s% b---------------
\b
! l& ]" m1 H( G. i9 A7 PMatch at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
7 ?4 w5 K5 f! D- X2 k% ~7 Z- B0 K1 |\B
Match in the middle of a word
egrep “\Bblah” sample.txt
4 W7 x- E4 h- t. Y& Z$ yMatches “sublahper”, etc.

间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
; ]; h5 [% s9 z8 Z5 y! \
egrep “(n|m)erd” sample.txt
+ [, F, h5 ~  f3 A' ?: ^
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
% I5 ~$ F) |& \! }( @4 a, ^/ ~- ?
) E5 A5 N/ l. v% a  \  Zegrep “[nm]erd” sample.txt

当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。
* e, T6 l) v2 c5 d
第四部分：
" h) }) ]9 F4 z) C----------------
一些保留字符
( z) ?* C; u' `; b; B  @3 tRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
* y- Q2 ], s. J/ _1 p# r( \. X
$ S- }7 F' {& K( c^ (carat)
. (period)
[ (left bracket}
. Y$ x2 Z( \. N% o! x( B6 t$ (dollar sign)
( (left parenthesis)
1 j' s7 W# ?& o$ S* a) (right parenthesis)
* Z( u' Z; a4 _# R| (pipe)
* (asterisk)
+ (plus symbol)
8 Q3 c$ m. B) _* @9 ~8 J1 |? (question mark)
{ (left curly bracket, or left brace)
! Y* p' ?5 c0 F/ C' x# i\ backslash
" ~7 e, {  u0 O一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

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

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

+ g/ Y* @# O! H) {: L8 B总结
$ E3 m' v: O3 X+ e% m% M, x- `在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
' j9 \1 P% }" `
另外一篇文章
----------------------------------------
' R# }3 Q( q$ T, m- E5 W2 p4 |正则表达式和Java编程语言
. o' @4 g- `) b2 d* i- R0 C-----------------------------------------
类和方法
3 |( w* e/ \0 P- v
下面的类根据正则表达式指定的模式，与字符序列进行匹配。

. g) ^% b! X; k( P% {: sPattern类

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

用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
3 Y4 T. I/ Z! r2 G0 L
: G* A* d: R& t5 W! ~( w9 q用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

: K1 Y# V/ A+ r" K% i4 Esplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
/ f" Z4 U2 p8 r' p* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

public class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
' W# T! m+ G: fPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
4 f  k& x  L1 Q" r3 s& IString[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
}

) A3 f; d0 J7 a( G: ZMatcher类
! H" ?5 y2 x, J) r
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
. s/ K1 l" r. h3 G% w( C9 m" @) K. a
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
6 W( T# A; V% v/ Q4 f9 F8 t! JlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
: D1 p! I$ A! ?, M' Wfind方法将扫描输入序列，寻找下一个与模式匹配的地方。
6 H( b  q/ P2 S7 U' G3 P7 }# ~
这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
2 _6 R( `: ], l( p3 R
, O" n0 X6 {8 b  _7 s) V这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

. g" O2 E  Z% t. t0 gappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
: Y4 g+ Y$ J4 W( g/ l
例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

* E  R" v) ~: {# v. a/ s% f' xCharSequence接口

CharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
) V" O% ?( G! E; A: L  r) w  v
Regex情景范例

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
! Q1 I6 ?7 P0 K$ X5 R) }
简单的单词替换
# i5 f+ T# K2 Q' l( r
" l& R% ?2 m7 a4 x/*
* This code writes "One dog, two dogs in the yard."
% m) V0 A0 g- T4 @; O* }* to the standard-output stream:
*/
1 g  g  t) \: |+ limport java.util.regex.*;

/ K+ m- H* I$ ?& ?2 H9 H/ C0 Y6 }public class Replacement {
public static void main(String[] args)
. h& ~6 i$ ]$ A       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
" \/ p) }# _! z) ]4 u. NMatcher m = p.matcher("one cat," +
3 m! @+ F5 b! S1 z$ q+ S! k* ?     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
; @; M9 |( ?- k/ \9 H' o// Loop through and create a new String
// with the replacements
4 C" t; V1 u8 d4 R) K  bwhile(result) {
m.appendReplacement(sb, "dog");
result = m.find();
* X1 u' V5 _6 w. ]: U1 Z  e4 |}
// Add the last segment of input to
// the new String
m.appendTail(sb);
System.out.println(sb.toString());
0 U$ D, p" F8 L3 U4 z* Y" g}
}

电子邮件确认

4 V" m+ b' {: K$ a2 B3 F以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
: r; F% g9 a; s2 Z$ f( r* Y
/*
* Checks for invalid characters
' K$ R3 }- h& e& V6 t* in email addresses
! g+ r( T: \# \9 C& Y# W' T2 l' l. p4 {*/
public class EmailValidation {
public static void main(String[] args)
           throws Exception {
# W2 S, d1 g/ V           
String input = "@sun.com";
( w  s  k1 r! ^* V4 I6 k//Checks for email addresses starting with
5 m. G3 g5 i4 b: L7 Y, B+ W//inappropriate symbols like dots or @ signs.
2 J3 k) q' Y& M7 g' O' kPattern p = Pattern.compile("^\\.|^\\@");
5 w2 Z  M! q5 w( [# qMatcher m = p.matcher(input);
if (m.find())
" b; D3 A5 i6 R6 h. \System.err.println("Email addresses don't start" +
" F1 @/ C; r6 S* a& ~( P         " with dots or @ signs.");
//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
$ e0 j# J5 n  \, |5 vm = p.matcher(input);
if (m.find()) {
% l: H# r6 p; [' \4 c  l, oSystem.out.println("Email addresses don't start" +
* s& P4 \# r5 R1 u   " with \"www.\", only web pages do.");
  e4 x# E: \. k}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
) c' L2 a% m$ r( O, k0 A, ?StringBuffer sb = new StringBuffer();
! S. y+ C+ _1 j, K, R, jboolean result = m.find();
boolean deletedIllegalChars = false;
' ?& ]* J7 W4 p6 \
while(result) {
: C  c6 ?2 p& c8 u! \0 G* U" cdeletedIllegalChars = true;
, e( g3 q8 a+ y) w* a' s8 |m.appendReplacement(sb, "");
result = m.find();
# h$ K! L- A/ ?}

// Add the last segment of input to the new String
m.appendTail(sb);

! G4 C' Z' H) ainput = sb.toString();

if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
# m+ _$ C7 [4 L( I}
}
}
( Z' c/ y8 |6 i! Q
- F$ u; \( j8 _: T从文件中删除控制字符

/* This class removes control characters from a named
* file.
*/
import java.util.regex.*;
import java.io.*;

. ]9 l$ e: k% H) spublic class Control {
public static void main(String[] args)
           throws Exception {
           
/ y4 }% a6 B, Y5 l1 C& M5 r' G//Create a file object with the file name
//in the argument:
0 ^3 F' c# ?( j% ~3 g: KFile fin = new File("fileName1");
File fout = new File("fileName2");
& l9 l$ v2 v* T8 g8 P$ X; t//Open and input and output stream
, P* Z: x/ S; p6 `  p6 ?FileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
# ~' J  y: T9 N$ v( j2 q, J       new FileOutputStream(fout);

: N& M% q+ t& t: p- _BufferedReader in = new BufferedReader(
6 P2 R4 M& w6 k* Q- R     new InputStreamReader(fis));
* T) |" P+ {( j. R) O% ?BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

& u; O9 }3 M! \- F0 o5 S// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
( p9 N; @# a. F$ ]5 }$ OString aLine = null;
while((aLine = in.readLine()) != null) {
0 a6 K3 B  t$ P, ^' m$ ]' Zm.reset(aLine);
//Replaces control characters with an empty
3 [2 N; u" ?+ G9 L//string.
: V- |8 C8 `3 `( P4 e; Q3 ~String result = m.replaceAll("");
8 Z# `& A/ H" t. g2 e3 P7 iout.write(result);
out.newLine();
}
9 O" W4 H* X2 {! Rin.close();
out.close();
4 V  p2 ~( O4 x) e, z' o}
- _, Y/ W% F7 L. a; v9 |}

文件查找

/*
: L- `7 e) [% o8 d/ R* Prints out the comments found in a .java file.
# u4 u6 T+ Y3 G% q: [0 y% P" U4 K* O*/
" y# [- u  U# q* N: timport java.util.regex.*;
1 c9 c- p3 u  z( ?- R6 Nimport java.io.*;
1 u- S! J' U2 p. p4 L& C6 S7 jimport java.nio.*;
8 @! g+ @$ c4 K! }import java.nio.charset.*;
import java.nio.channels.*;

; p& Y9 c  {2 x" U+ Bpublic class CharBufferExample {
+ q3 ?: q( k  ?4 ]1 c9 K$ G' opublic static void main(String[] args) throws Exception {
// Create a pattern to match comments
7 e- [7 ^0 K2 I$ N7 \Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
5 c- z$ T: @2 G( K; cFile f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
/ b. S9 P! {% x3 i/ o& ^* XFileChannel fc = fis.getChannel();
, Q7 Z. v3 p7 N8 |4 e6 k; N: {' q
// Get a CharBuffer from the source file
" C9 x' F& i0 P" F; @2 |ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
7 f5 x  ^: Z! G: L$ A. R5 ]Charset cs = Charset.forName("8859_1");
7 ~% x) q! W/ iCharsetDecoder cd = cs.newDecoder();
4 ~0 P3 |2 B) h' d" ]& X9 h% aCharBuffer cb = cd.decode(bb);

// Run some matches
4 C# x2 m9 m. |7 M& S( k4 rMatcher m = p.matcher(cb);
while (m.find())
. W, q; {* M2 p' k2 F% k' B, iSystem.out.println("Found comment: "+m.group());
* |1 l% |( U% {}
}

8 p# H! e* U# ]结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
2 _" H  T' z( G1 t- q# y
! L5 z5 t$ W$ B( ~2 [JDK1.4之正規表示式
! k0 L8 v& m: L% ?6 L8 v! Awritten by william chen(06/19/2002)

) I( M8 m, o. J4 O/ l6 s" F4 O--------------------------------------------------------------------------------

# ~, i7 y7 a0 f6 W( }什麼是正規表示式呢(Reqular Expressions)
' P1 Z0 r& Y6 H$ m7 B# q
; f( v; h0 n2 Q: g0 M! Q就是針對檔案、字串，透過一種很特別的表示式來作search與replace

! ^$ ?. ]  Z1 G6 v因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

所以發展出一種特殊的命令叫做正規表示式
' Q1 j! f& u# w. N% c
) {2 a, F. `6 I# r: p6 h我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用
7 `. {' H: D# m+ P4 ]- S; u
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

) q* c: A3 I* g5 e剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
* w8 L* Q) L* m# ~
"." 代表任何字元

正規式 原字串 符合之字串
& c" R. G1 a7 e7 M5 l. ab a
9 l6 \- S. |- j& Q.. abc ab

  ^! T. B  {' z: x"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

( f( O  U7 {, r- [% V" b8 P1 `$ G正規式 原字串 符合之字串
+ ab ab
; r; G2 F6 {5 p8 Q6 s% @1 E. o  i* abc abc

"( )"群組
0 \2 R, B- @, l7 ^0 ^( x0 f
正規式 原字串 符合之字串
(ab)* aabab abab

字元類
+ w" I3 j0 d( W6 ~$ p
正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab
' ^( R+ V- {; d. q' e
- Y0 J* o, }5 ~# L5 l6 e
& Y7 _" o# }4 \, s. o( e簡式
$ k" ?5 C. `* r' c9 {
( o7 m! x5 y. E; v0 B\d 等於 [0-9] 數字
6 I7 H) d* w0 F% e" `\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
" h2 ^) j  S" i\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
& \' J5 C, y. g% w  _7 i! ~3 v8 Y
0 ]3 i% _+ w. R4 w+ A. y' F' O0 w每一行的開頭或結尾
" \9 t. m! `7 v0 A$ K$ a
^ 表示每行的開頭
6 _7 ?1 G) j5 `" A" Y# K' n$ 表示每行的結尾
4 p" t9 c/ t& a- p
( k1 m8 y0 j8 r8 m! A. `--------------------------------------------------------------------------------
6 K+ \$ j% c% ?, {- x" |- \7 y) `
8 K" d6 ~5 i6 m7 @$ _正規表示式 java.util.regex 相關的類別

Pattern—正規表示式的類別
* v2 t, w2 A. `, SMatcher—經過正規化的結果
0 a9 ?5 c, M  w- b. v/ E, LPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
3 ?# B5 T" C! T% L4 Z
7 v) e! V  ^0 S7 c7 q; ^4 \9 p# b% S: K( `範例1: 將字串中所有符合"<"的字元取代成"lt;"

' f1 Q3 k  x7 {  x5 E1 Cimport java.io.*;
import java.util.regex.*;
/**
8 v; V& j4 i2 D2 b! J3 H+ ~* 將字串中所有符合"<"的字元取代成"lt;"
*/
+ H' _+ W' c" _4 ]5 i0 t- |public static void replace01(){
# o  T$ M" L5 I% u( F; g; y// BufferedReader lets us read line-by-line
" n7 l" ^% L6 s1 k9 I3 ], l5 {Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
( N% u+ r7 \2 E$ }# Qwhile (true) {
String line = br.readLine();
) [* `7 |! S+ q2 M/ Q: L3 d// Null line means input is exhausted
if (line==null)
break;
6 @0 }- M$ V% gMatcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
}
% F3 W9 g7 {9 f5 o: x* qSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
+ }. P  s- F1 p3 Y8 i7 A) L0 i* ?}
}catch(Exception ex){ex.printStackTrace();};
, F1 r) t3 y$ O  Z8 [. j}
/ f8 L. Q6 R& h. }
範例2:
6 Y2 g9 }) L5 Y" u. n: W8 a% J! x
  R( v& P( P0 l' [5 @0 s: }import java.io.*;
+ y! ]. O' b4 ~( A- T/ nimport java.util.regex.*;
/**
+ _0 S( |$ G% P  J+ ~) E6 g3 a* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
. K; x! J8 |% I*/
public static void search01(){
1 @# d- I+ ]/ l! ?: z// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
# N5 v! {: f9 Q3 m8 l5 zBufferedReader br = new BufferedReader( r );
/ p; b# [, O7 b! D# c% LPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
0 w2 Y, i- j" e( x! Bwhile (true) {
! k- H& y0 k) m" j+ s. t; gString line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
2 C/ y( B  ~' a& U, A5 Vbreak;
// -1 means we haven't found a word yet
3 [  a& X8 s3 H0 `0 e+ i, o$ fint longest=-1;
int longestLength=0;
5 c' G0 U" Y2 O. V( Ifor (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
longest = i;
# k* D7 c; i* @longestLength = words.length();
9 `& d, M( h6 M; \}
}
System.out.println( "長度最長為:" + words[longest] );
; |# c7 Y! L+ Y- z+ i+ `- B* j/ ^}
}catch(Exception ex){ex.printStackTrace();};
}
9 l/ B) A# N3 S* l) D. r# n( U
& w" w0 r" J) u--------------------------------------------------------------------------------

其他的正規語法

1 }- f9 \/ W) `( w' f/^\s* # 忽略每行開始的空白字元
3 [! d! N: C: |" D* |& V(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水