关于正则表达式---ZT

Longe

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

, B& E- L/ b7 g; {2 _! C, M% ^) ~支持多种平台

0 Z0 U" A; s. A$ z, [0 L4 O" t8 H/ }
! Q( e" ^. s8 X# m. U正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
5 t& V3 A# l9 l
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
8 c" i' R. c2 l
7 ~3 P$ h- ^, D8 F4 g' `8 P" h: O) }正则表达式101
7 `1 m3 e0 O! {1 w! D; r! L* w很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
8 T$ i1 b4 K, J! _- ^
9 Y, \% H' k/ O, W$ M5 ?! R* N第二部分：
----------------------
字符匹配

# [, r! M# j7 Q5 z* ~正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

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

Table A: Character-matching regular expressions
( w4 y' v0 o* B/ _  U& t6 G: M7 R格式说明：
+ @7 i( L; e1 Y# n8 _' h+ Y, f---------------
操作：
" t& E& h( n. y; c9 T解释：
例子：
结果：
----------------
.
Match any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
( x+ f# e% f% Q0 XMatch any one character listed between the brackets
grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
7 r/ H6 C) i4 B8 O% h$ _+ n/ R[^ ]
Match any one character not listed between the brackets
7 u( C. `( h3 j2 l' B1 G- }
% [. {. [3 q/ k& z5 Q% o- xgrep [^cn]ord sample.txt
4 Q9 [# C; |9 W: l4 V# s9 S$ _Will match “lord”, “2ord”, etc. but not “cord” or “nord”

) m- ^1 Q9 `% j( f" w9 j; G4 j, W& Egrep [a-zA-Z]ord sample.txt
7 t! b0 c$ |9 v0 J0 B7 d+ b" AWill match “aord”, “bord”, “Aord”, “Bord”, etc.

grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
; @1 `$ d+ Z" d  @( H9 s- W+ }
2 N3 A- N7 P: v9 QTable B: Regular expression repetition operators
; a% P5 {& Y9 {- G6 ?) d0 d格式说明：
---------------
操作：
解释：
例子：
! S1 j" D8 u# a6 s- b+ Y$ X) E结果：
6 X) A+ \( G8 X# G3 d0 `----------------
?
& o- T8 J( W0 Y8 k+ H. u. JMatch any character one time, if it exists
0 W. J6 Z' n! Q( Vegrep “?erd” sample.txt
5 R+ }" D6 k/ B# D" oWill match “berd”, “herd”, etc. and “erd”
------------------
*
, g9 L. O" I( s0 ~4 Q5 ~/ d! L: ^& J: AMatch declared element multiple times, if it exists
& N! f3 o1 n4 I2 R5 U, s5 regrep “n.*rd” sample.txt
' _) q( [' `+ i4 I% v8 {0 |: MWill match “nerd”, “nrd”, “neard”, etc.
-------------------
+
Match declared element one or more times
, ?. p3 L  \# @* Cegrep “[n]+erd” sample.txt
: J+ {% s3 O$ C4 I5 XWill match “nerd”, “nnerd”, etc., but not “erd”
: J( D2 ?/ Z, K+ |5 ^--------------------
9 ^6 z1 u. f: _{n}
( g9 K! I7 T; f7 e6 X+ g: UMatch declared element exactly n times
; G8 U/ J: q4 C9 j2 y3 wegrep “[a-z]{2}erd” sample.txt
9 ]3 K+ p! B  G) _% q0 B$ _. X2 ^- SWill match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
* C. r2 Y0 {9 p1 n8 vMatch declared element at least n times
, R8 n1 q2 a( L% @" Jegrep “.{2,}erd” sample.txt
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
Will match “nerd” and “neerd”

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

s/pattern_to_match/pattern_to_substitute/

4 t) a7 L* u. m7 z  I3 _
9 ?- m) Y% n7 Q6 l( J' b0 o1 s" sTable C: Regular expression anchors
% P1 l5 `2 Y0 }3 p9 R9 F$ F$ f-------------
$ c2 R: }  v# L2 G+ f/ q# w操作
解释
例子
. w$ D& c2 D/ o结果
---------------
^
Match at the beginning of a line
! w  X( f$ U5 \1 N" o" Z7 Q+ [s/^/blah /
+ k* p1 }; D" `6 U2 r6 Y# u3 q  l) XInserts “blah “ at the beginning of the line
---------------
; `6 @. k' k4 L6 C8 Y- Q0 p$
0 v1 X; F5 ?) `Match at the end of a line
) r3 _5 s- ^1 a6 N2 L2 D  V/ }s/$/ blah/
Inserts “ blah” at the end of the line
; V9 T, [5 M+ m% p; C8 }! g---------------
% ~( p" _7 k+ x0 [/ _( C\<
Match at the beginning of a word
: {$ ~6 C  z: L# As/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
6 e& V: R% S- }6 I1 ?* k------------------
\>
$ x0 [9 i) I( h2 t7 {: OMatch at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word
  z1 a/ |2 E) d0 T2 ?! w7 k( R
1 E( a. ]2 t4 Begrep “\>blah” sample.txt
: l; m2 b) m3 _0 R) Y, u; BMatches “soupblah”, etc.
---------------
\b
$ B4 |( q! i3 y& J, [; tMatch at the beginning or end of a word
" ?  C4 R( h0 O& E. s! ]! uegrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
\B
+ B! P  d: y1 q; Y2 Q$ y6 [/ DMatch in the middle of a word
- y* f9 x* ?  B+ v2 T  \& t$ megrep “\Bblah” sample.txt
Matches “sublahper”, etc.
) E3 V0 j1 f0 a1 \
间隔
6 W- W; w) _/ ~+ I4 h8 l5 ^# f
8 h# ^9 T$ J& o$ }- A( B0 PRes中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

egrep “(n|m)erd” sample.txt
/ g- p1 E  s% r5 c
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt
- u6 l& D. N, E' O4 N+ v5 ^4 J+ h
; p7 t. Y5 R6 J8 j当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

% Q2 s- A& Q5 E; F$ o" F第四部分：
----------------
7 Q) u( Q2 }4 q一些保留字符
( ]4 y6 Z" N2 [; y; F: ?& l, j; mRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
+ q2 j& G, w7 Z, h( t: v
^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
| (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
3 _4 ^$ w: E6 R8 @{ (left curly bracket, or left brace)
$ `' t8 I: N5 C. u/ ^7 k\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

. i+ }) [8 D) }, beregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
7 J- y0 w1 b7 q; x3 x0 I
3 R/ l& B: ^& O你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
$ y6 l9 a. F, c; I0 g4 \
总结
" I4 A* }5 G4 D( {% C! M在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
! y  N* Z8 r; w* c3 W% H
% j, V  v, R6 c# s另外一篇文章
----------------------------------------
" O- v) ?5 F0 o( v0 j正则表达式和Java编程语言
) M2 c5 _& p; q6 A-----------------------------------------
类和方法
3 R$ f6 V, t7 O! B! Q. O- Q( b
8 q2 d9 q1 v! v9 d5 `: n' J下面的类根据正则表达式指定的模式，与字符序列进行匹配。
- Y0 D4 J! S2 P# E2 {
2 v9 i- u4 e1 YPattern类
3 p1 T8 y; c( O3 {6 K$ {
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
, n/ R0 e0 j1 T- N" v3 K# L. ]
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
% \8 j2 M: ?2 ~& a8 T( W: V: {
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

( R$ A5 P. Q; a7 S) }/ R5 qsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
' U3 T' L5 Q' w! Y* 用split对以逗号和/或空格分隔的输入字符串进行切分。
* t* V1 K: ]+ w! ^- v2 B, Q*/
* V2 p0 z7 p& L& p- ?! H: Qimport java.util.regex.*;

2 Z/ Y; U+ d. C" |. l9 ^public class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
! A% S1 D: K  |# qPattern p = Pattern.compile("[,\\s]+");
/ [2 B% q) z5 _) s// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
}
}
5 T: Z% m% P2 ~1 ?* d) r
& A# y) _6 Z9 m7 @6 c7 qMatcher类

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

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

matches方法试图根据此模式，对整个输入序列进行匹配。
9 c2 f4 |3 _$ I# FlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
) S: r6 q. d/ h: ?9 `& D  ]: L4 ~/ T$ o
% g/ q: W, x; p/ n8 m( ]# B这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
+ Z$ v3 w4 h( F! q0 Y
1 Y6 M# b( n0 b4 i例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
+ R0 k( K) p' Y0 h  K
1 {; }3 a3 U9 v( o5 j* T8 KCharSequence接口

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

以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
2 m% s5 X0 y: _" E6 B. S
6 p6 i+ j! o4 e( D6 F简单的单词替换

/*
" I: u6 W" h8 r% n0 E' g* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
/ G! o5 d9 {- p% p*/
! k  W- _3 _# W7 J$ bimport java.util.regex.*;

public class Replacement {
public static void main(String[] args)
* S. I# Q5 o, J5 l3 Q       throws Exception {
4 A! U0 Q3 o1 F0 S// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
0 k. J7 j' h/ r// Create a matcher with an input string
: G* R, u3 o/ F4 g5 RMatcher m = p.matcher("one cat," +
& S9 v" O$ i- N" F2 v     " two cats in the yard");
, q' Y0 R* i) J3 }9 R  I. aStringBuffer sb = new StringBuffer();
boolean result = m.find();
3 |' M& Q; E2 t6 E6 `3 ]' b// Loop through and create a new String
// with the replacements
while(result) {
m.appendReplacement(sb, "dog");
8 J3 d- m1 v  C9 U; @$ a; nresult = m.find();
) Y$ ]9 _2 @8 N& G}
1 C- q9 ~9 K3 c; w8 S6 e/ f6 v// Add the last segment of input to
7 B( e# I2 T+ ]! c; }9 K5 S// the new String
m.appendTail(sb);
System.out.println(sb.toString());
- T+ t. [" @0 O  X}
% r. S# Z$ W% W( y}

电子邮件确认

: b5 ^+ a8 F5 v0 V, Y- T以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
( s0 s! k. ]1 F% R0 I
/ B6 }& M* C8 r- t) v! G) ]3 Z/*
* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
% t$ u/ v* W5 f! {public static void main(String[] args)
  @  z- b* s$ M7 K           throws Exception {
3 E0 l8 _! g- u- K: _           
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())
( ?# i" d7 i  y1 i  p5 mSystem.err.println("Email addresses don't start" +
. T" K& z& v( J         " with dots or @ signs.");
3 T' {& |* v/ @) m//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
& W0 _# O- V3 y5 nif (m.find()) {
System.out.println("Email addresses don't start" +
. Z3 o: }& Z( e. F, f: {0 m6 ?   " with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
. h- s+ ?0 t' H6 X2 ]+ h) _3 h) [5 dStringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
  z3 u* v% r& ]$ c5 |, X
while(result) {
deletedIllegalChars = true;
) g* F4 ]5 ^9 q! k1 z; Wm.appendReplacement(sb, "");
result = m.find();
* W3 b+ z9 T/ H6 A6 u" E}

// Add the last segment of input to the new String
5 }* b' f8 y1 ~! y; Nm.appendTail(sb);

6 C, B3 f- |/ |  w1 n- minput = sb.toString();
" j8 m, h, G) _5 V. [
! ~" E- V' f+ U+ K0 H% Nif (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
/ H! t: l, Y6 _4 ?3 W, I- [$ j       " , such as spaces or commas.");
}
}
}

从文件中删除控制字符

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

# M' o% Y" e* D9 Dpublic class Control {
' q8 m' i5 q* a9 F" D; Upublic static void main(String[] args)
. [* C2 J  F, i, [7 B5 Y+ T4 C           throws Exception {
           
//Create a file object with the file name
//in the argument:
) a) G7 D  A4 [: R+ cFile fin = new File("fileName1");
File fout = new File("fileName2");
0 r( I1 g: C' ^6 s  m& r//Open and input and output stream
4 T4 v/ @3 o& ], z8 k. r% L$ HFileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
1 y2 r' X& e8 g% Q" {" P' n       new FileOutputStream(fout);

. J2 H* i& u- L; m( f( {BufferedReader in = new BufferedReader(
" B, K3 K" N, h# W! h6 T     new InputStreamReader(fis));
3 k6 |- y) m/ f/ cBufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));
* {* m# N% q$ E: r/ Q
// The pattern matches control characters
: ~7 W$ D- c3 D; dPattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
+ ]6 v2 P" n+ r5 Z. A5 k1 ~while((aLine = in.readLine()) != null) {
m.reset(aLine);
# K% L5 Q. p* i0 k+ J& j) \( f//Replaces control characters with an empty
//string.
String result = m.replaceAll("");
out.write(result);
out.newLine();
}
in.close();
! `/ y: }1 x2 e8 z8 A0 pout.close();
( _+ V5 @# w, s& ]2 Y& a7 \}
}

: o# g. v. W8 r" f9 k$ C0 m' c& @文件查找

8 b4 y; H3 [) s/*
* Prints out the comments found in a .java file.
$ w0 w5 b7 g, D*/
/ \# W) |8 I: @- C6 Q( @import java.util.regex.*;
import java.io.*;
* ~2 M2 C6 V" W2 ximport java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

- m+ v. _5 d; z  }* Ipublic class CharBufferExample {
public static void main(String[] args) throws Exception {
2 b+ a8 Z& z+ M( S; ?// Create a pattern to match comments
) E- v9 Z7 q7 \& yPattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);

// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
& ?/ I0 K  U& Q+ c6 V! O' ZFileChannel fc = fis.getChannel();
5 g2 V$ B% F: c1 ]+ u, E7 N! x
// Get a CharBuffer from the source file
( ]6 ?% ]6 z$ A* GByteBuffer bb =
8 X1 u$ R" T- R! \fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
7 }5 }. ^' z# X% k0 C4 \Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
/ z% B, }0 v# N0 LCharBuffer cb = cd.decode(bb);

$ L" f4 y" f$ C1 @: L// Run some matches
Matcher m = p.matcher(cb);
& P4 X6 @0 Q* o8 o, Xwhile (m.find())
7 c1 i: Z) c" B% d/ o7 JSystem.out.println("Found comment: "+m.group());
}
- u; ^: Y- d* W( D/ j6 P9 p: L1 i}
8 T7 J( p* l  a7 Y: q0 Z$ u( D
结论
现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
+ t' G) B& Q! K! O! r5 V8 ~  r2 U
JDK1.4之正規表示式
written by william chen(06/19/2002)

" A# T9 U+ U1 `1 y$ Y* K6 p--------------------------------------------------------------------------------
" I( ^8 c7 j' R6 y1 E9 X" b
  q" r0 m+ H) c( O什麼是正規表示式呢(Reqular Expressions)
) A% i% _" l  c/ E  v
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
. U- ?8 q& z2 u% A. Z: o7 \/ t, V
因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代

$ w& g+ ?4 h- G; R7 Q5 j所以發展出一種特殊的命令叫做正規表示式
! ^, I/ m0 D! M- i/ F
9 H& m) A0 W3 @# w1 s- f3 _我們可以很簡單的用 "s/
  W# T. @7 m8 a! ~& r( k因此jdk1.4提供了一組正規表示式的package供大家使用
" z6 w$ u* u) N
1 |* _# t' S! D' x若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

; _- R: N! H8 ?/ s! b  g剛剛列出的一串符號" s/
# e0 ]; E. U7 T適用於j2sdk1.4的正規語法

) {7 @( R1 n7 t. `, k"." 代表任何字元
% P- y! `4 o; H! t3 d5 \$ V
正規式 原字串 符合之字串
8 I$ t1 ]$ Y% l9 s- g% W. ab a
1 S+ f5 N6 Z: R* J2 i" P.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
. I' |0 {& b$ p2 h9 H9 f6 t9 e! w+ ab ab
, ^3 C8 }3 @) T% r* abc abc

"( )"群組

0 I- r1 y: W* J1 {- G" @6 f正規式 原字串 符合之字串
(ab)* aabab abab

字元類

2 W! \, j' U, Z5 N0 c正規式 原字串 符合之字串
% @1 y% C! \5 r: |" U) Z; M[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
[a-d]* abcdefgh abab


簡式

4 H" U% [$ }9 H\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
3 D0 B( M! G6 `6 X! Z\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
8 f4 t1 L# u" u4 U4 u\w 等於 [a-zA-Z_0-9] 數字或是英文字
6 K) ]" M! ~7 W5 v9 D2 f5 z\W 等於 [^a-zA-Z_0-9] 非數字與英文字

9 c" u6 B1 O5 B& I- [每一行的開頭或結尾
; n2 A, m! r2 Z+ r
^ 表示每行的開頭
$ 表示每行的結尾
% e2 K$ G; p! _% c
--------------------------------------------------------------------------------

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

* }. u$ ~5 J& [3 qPattern—正規表示式的類別
Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

/ Z1 d7 v5 H* X4 T3 S4 T, Y範例1: 將字串中所有符合"<"的字元取代成"lt;"
5 C2 p9 t: D' O$ ?3 R" h# }& j
: B: Y- C0 N& V* i6 ~8 Eimport java.io.*;
import java.util.regex.*;
% E5 e: |5 P+ W+ Z$ d; V0 F/**
* 將字串中所有符合"<"的字元取代成"lt;"
' U# ^2 i: l6 F' ]5 b6 j*/
public static void replace01(){
// BufferedReader lets us read line-by-line
# v8 Y' o  o- L) wReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
2 w+ i" D& d9 Z9 y: TString line = br.readLine();
, O$ T5 v6 L6 M+ U0 R0 Z' w// Null line means input is exhausted
if (line==null)
break;
# k3 ^. l" t6 t6 [9 oMatcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
! K* D' r  D$ {# d% s+ V7 p}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
0 Z, {7 O" M( e6 q}
}catch(Exception ex){ex.printStackTrace();};
8 L& X/ p) f2 {; f# `}

範例2:
  Q& ]) ]7 G, p4 F9 s% @$ m' |% S
* j7 R& k6 D+ }( K+ iimport java.io.*;
import java.util.regex.*;
/**
, R6 @7 n' [: Q' w$ o* 類似StringTokenizer的功能
& z& \, o6 E- \- i/ r+ Q: ?) v8 g* 將字串以","分隔然後比對哪個token最長
*/
4 n, [6 V0 i/ l/ W1 gpublic static void search01(){
: `1 V; e3 N5 v: X/ G% m5 Z9 t// BufferedReader lets us read line-by-line
+ ~& Y' M8 f5 b2 q: k/ o' {; PReader r = new InputStreamReader( System.in );
' \, ~* o. N1 lBufferedReader br = new BufferedReader( r );
2 _0 n! X: }. L& N0 ?& qPattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
5 x2 K  c2 _$ N6 H$ B( M' w' atry{
# w+ ^/ u0 [4 D5 xwhile (true) {
String line = br.readLine();
String words[] = pattern.split(line);
1 ^2 E* w% ~1 z// Null line means input is exhausted
if (line==null)
/ V0 v# L; ]6 p" d4 m! z. J, R4 Zbreak;
* w( o  p' R) O$ M: p, ^+ m) ]2 @// -1 means we haven't found a word yet
( e" b9 y+ k; [. g- S% L) \( B/ |int longest=-1;
! B4 ?) Q( A+ G4 X- `& Wint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
4 y# `6 i8 Y8 Ylongest = i;
9 H8 c; u& e* L8 RlongestLength = words.length();
}
}
) o* {6 }+ w4 B8 c: p2 Z7 S% h9 HSystem.out.println( "長度最長為:" + words[longest] );
7 q# t, `2 b( _# m. ?8 r}
, u4 F* s4 G& l' Y, |/ Q}catch(Exception ex){ex.printStackTrace();};
}
3 [" y* i" y$ k+ `2 s8 j5 G: F3 o
& g" \& K# w3 X--------------------------------------------------------------------------------

$ R7 A% L) y& d* ]) @其他的正規語法
, j) M/ a6 i8 y$ j! m
- b% H# e! T) a/^\s* # 忽略每行開始的空白字元
, H  @$ h: T, M+ s: n: H" L(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水