关于正则表达式---ZT

Longe

第一部分：
-----------------
& ?/ R! n( v& M8 h8 d6 [5 |正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
7 [+ W: Y( V% d( w
支持多种平台
5 ~$ n/ \) D5 X9 ~5 x
5 M* v- g3 h6 _1 [' q
$ ]# E# t0 A3 i- T/ o# c正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
8 B$ A$ r6 }1 M( i8 G
6 C$ n; A( c: p" ^正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。
6 S& B0 b7 P9 k0 f& I
6 _8 V# n2 u5 \& \% x0 `许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

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

2 K$ o  ?+ K- C) P( @0 @正则表达式101
. n4 y3 m. e1 H" I2 X4 L2 K3 N2 \" A很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
' I5 @" J# ^8 K6 t! k) i" p
第二部分：
----------------------
8 s% c1 x  y9 r$ t: O字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。
, a! p' @" _# g7 c
每一个表达式都包含需要查找的指令，如表A所示。
% o! c2 F, B  c2 @4 o
Table A: Character-matching regular expressions
格式说明：
---------------
操作：
! |8 v: v8 H) W+ n解释：
$ \: M, P$ F0 b, I例子：
结果：
----------------
.
Match any one character
grep .ord sample.txt
7 q2 W1 {; m/ c; @! i1 _& q$ MWill match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
$ Y2 _  _0 i/ P. g: j1 c/ P5 w9 j-----------------
8 q3 ?4 R. t/ I% x+ Q( j/ c[ ]
) d+ |$ H. L+ \Match any one character listed between the brackets
2 X. Y) L& j6 agrep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
% ~; ]! c3 q0 }0 p[^ ]
Match any one character not listed between the brackets
* w/ W/ [  ~5 I
+ Q4 q  k$ @" W" r/ y( x& S1 i# ^grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
8 I& q) b, f# I
" {- L6 B# a6 N4 pgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
7 l6 u' x: ^7 K. z$ A  Z
grep [^0-9]ord sample.txt
/ i  `/ C' _# @% J0 q8 q0 VWill match “Aord”, “aord”, etc. but not “2ord”, etc.
  W+ |; U5 R/ I3 s2 d  ?) A' d
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
6 a5 a& R2 `) z$ Y
Table B: Regular expression repetition operators
格式说明：
---------------
操作：
解释：
7 m9 \/ g( |% b: W0 U- X例子：
结果：
----------------
9 P, Z9 e$ Q; m# s+ @?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
/ L7 n6 u& f8 y9 @*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
) {" v: l- z$ j4 Q5 j9 Q" _Will match “nerd”, “nrd”, “neard”, etc.
3 d+ N4 v# b# ~3 |7 Q-------------------
  n/ i- G3 l( n" {+
Match declared element one or more times
egrep “[n]+erd” sample.txt
" N7 K7 @, O/ O$ }0 ~: fWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
, H+ |8 M& X; a: C{n}
+ d) x! v3 ]) `; J% }- H7 v3 NMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
" K4 m7 ?  \& A0 @& f6 f+ y------------------------
{n,}
7 p1 O* ^% c6 [! {2 I5 c6 jMatch declared element at least n times
egrep “.{2,}erd” sample.txt
5 k; ]% m+ t# B' B7 Q6 Z+ d1 N3 i0 HWill 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
# {* q# [* w. Q- B9 AWill match “nerd” and “neerd”
5 v! k' [9 m/ m6 i
第三部分：
----------------
1 e; J5 j( b7 e, w( \锚
; E; Z. H2 K. |  p  I0 n锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
4 ]7 C* L( t; u; l0 Q; ~& q( n8 `
s/pattern_to_match/pattern_to_substitute/

$ S. W4 d! C, K, F0 r' @
Table C: Regular expression anchors
! g5 O6 ~' e& i* I-------------
操作
" b+ p2 K. o9 ~# X1 t8 r解释
) B# O" G* i1 L0 m  V: N$ S4 F例子
( r' D7 p7 X' s结果
2 |2 T" i( U/ K; y& {7 x# u% f---------------
^
+ j. K+ g7 _: X+ Y/ \Match at the beginning of a line
s/^/blah /
5 K3 x1 e! ~: Q- y* IInserts “blah “ at the beginning of the line
  I7 o7 b% a- ?3 S, j6 B0 |6 B---------------
$
Match at the end of a line
s/$/ blah/
. ~. K+ L9 C9 e7 \8 i" f& oInserts “ blah” at the end of the line
---------------
+ k& \2 o; X' Y! p9 A5 N\<
4 a; ?& M7 O3 X" LMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word
  C0 Y, [7 n5 U4 y$ D: ~0 l
egrep “\Matches “blahfield”, etc.
( R# k( E4 ?. i) g/ G" [3 d------------------
\>
1 @  F8 @+ {  g- Y% ]+ pMatch at the end of a word
  R) V+ O0 J, D0 Q3 ^0 _# ts/\>/blah/
Inserts “blah” at the end of the word
( I+ o# l3 t3 V: e3 |. T5 H
egrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
) _: c% e1 J$ t. J  B/ B\b
Match at the beginning or end of a word
3 R9 q, C: U" @8 l/ I4 r# O9 q1 \& Qegrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
' l, }" P% l1 o-----------------
7 n" {2 ?' Q4 N\B
  q" {* _$ y" VMatch in the middle of a word
egrep “\Bblah” sample.txt
Matches “sublahper”, etc.
( r& @; p6 O+ f5 m! ]
间隔

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

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

3 W$ Q/ ~* K, L2 |+ s4 o. P% }$ U5 f间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

) f) W4 B6 ]# c# v, W4 Negrep “[nm]erd” sample.txt

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

第四部分：
0 b0 t/ V- c  W; c5 ]----------------
1 T  @( E+ X+ `% Y8 o! q2 @一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

% }9 c2 M4 ]' k0 [^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
# C( a) X# w% c' v5 k, Z* M2 F) (right parenthesis)
| (pipe)
8 \( Y9 \# S* l) n- I' P: w* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
- n- o- @. G# ?6 ?- Z. F\ backslash
8 [+ F8 n% ]4 u8 A6 ?& x一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
- J7 S- k2 h/ v1 b( y& ^  t( m
eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
" v$ I+ H8 K5 r1 d% E" @$ v. `
总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
7 c' g& W0 |/ I
! u( _7 |' n/ d8 E9 V! W$ z- D+ [另外一篇文章
----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
; {3 ]% i9 q/ @- `9 ~, ]! [7 n类和方法

, P9 [  _$ t! }8 D: a5 a下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
6 r. m* p$ d. S/ p* h  A
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
; I! r2 r+ r( {! @
用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
) E- Y$ _" i3 D2 P( y% ?' I
用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

( u! v" b2 Z' ?1 Xsplit方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

$ A; u( ?* V$ r, I8 p/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
( H& m4 n6 |( R) o9 k) F- Nimport java.util.regex.*;

public class Splitter {
" d2 h' t4 i9 Wpublic static void main(String[] args) throws Exception {
* l4 j( R0 k+ G5 p// Create a pattern to match breaks
Pattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
String[] result =
& ^% y- [8 ^1 N  h" r- b   p.split("one,two, three four , five");
$ {" i$ L+ v. v1 ^8 ?0 ?for (int i=0; iSystem.out.println(result);
}
9 A. l, u; g, s0 m4 A4 P" _7 ]0 }% k}
" U# O" U9 f+ R$ t+ Y
# O" S& j. @0 j, l# Z0 LMatcher类
- j% e$ T' S1 E4 p( Y5 G( h1 O
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。

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

matches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
) F+ e+ B" O; Z) G4 V+ l% q
! |) H1 k$ Q/ f4 j: m这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
" Z  m6 N5 X* s3 N7 \8 E5 g
appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

- H6 T4 n. I7 b1 l7 ^' a! `例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。

9 g' r0 L0 x! `* sCharSequence接口
/ j3 z6 {% K1 }8 N7 R/ E
5 u: _; G. V2 W+ l& O/ wCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。
0 c9 a$ s% U' X- Y2 W3 _; M7 Y
Regex情景范例

. q3 |2 M2 z! @以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
( W' |, w! G! u4 F& @% s
5 F- m! @* B" v4 L$ x$ }简单的单词替换

/*
" N# `8 i$ ]3 _5 q+ G; E* This code writes "One dog, two dogs in the yard."
5 ?  B2 j4 y# k: s8 N* to the standard-output stream:
*/
import java.util.regex.*;

* t  E4 Q+ l+ n2 [; Upublic class Replacement {
- P9 u9 }* [0 i1 [8 k8 Q, w- xpublic static void main(String[] args)
       throws Exception {
/ M: D% ~* ^& r5 j# T8 _// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
* A" p  s# `* n; C+ M( Q" [& S// Create a matcher with an input string
* r* R+ }1 l2 v# N- t0 gMatcher m = p.matcher("one cat," +
     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
0 m/ B# x8 G$ V. }/ {; ~// with the replacements
  x( B) O$ v/ j) A4 f* u6 H5 pwhile(result) {
4 K$ u. B# j0 S0 \' u1 Im.appendReplacement(sb, "dog");
result = m.find();
6 ?9 h- _1 C9 a4 E" V; t}
9 s! z2 \: T% F9 H: Y// Add the last segment of input to
// the new String
m.appendTail(sb);
4 c; T" r6 n2 _: qSystem.out.println(sb.toString());
}
}

电子邮件确认
* p: T. C7 y* B% Y' }  T5 v
以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
6 w0 S. _6 E4 u& T2 t! v$ g+ @* Checks for invalid characters
; h, H' S$ g" Z* in email addresses
' i( [  i3 m+ x# f: \*/
$ U/ E3 a+ J5 }7 f& jpublic class EmailValidation {
public static void main(String[] args)
           throws Exception {
. A( G3 j+ Q4 S0 Y  F: J           
7 G" p# p8 L9 y! H/ }1 pString 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())
8 C! G+ u; Y- G% t! o8 x1 [  G# JSystem.err.println("Email addresses don't start" +
* A' |  P* l* t" W         " with dots or @ signs.");
4 w  H* Q3 P9 i# d//Checks for email addresses that start with
//www. and prints a message if it does.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
% k1 r2 U& W: ~4 q3 J. OSystem.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
2 j4 ~9 [- j3 A2 }; |}
2 b2 ]+ H8 o) S0 E( ~5 i% k+ Op = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
" Z: @5 o2 V: N) {6 r% d+ Im = p.matcher(input);
- k7 D* ]2 ^- q* q" Z, D9 V  hStringBuffer sb = new StringBuffer();
, |7 j' q8 Z! G8 K: K9 b% Sboolean result = m.find();
boolean deletedIllegalChars = false;
0 _4 c9 d; w& {8 f
while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
. j# E% K. w% f3 ^}

; P5 H% j" a. M5 w. e// Add the last segment of input to the new String
m.appendTail(sb);

! U( J( d$ |% v+ V3 \$ T% @input = sb.toString();

* s' L+ ^- L4 M+ Z: rif (deletedIllegalChars) {
! H- f& U6 g6 o4 @  J) kSystem.out.println("It contained incorrect characters" +
       " , such as spaces or commas.");
8 t7 C$ H2 t2 z; H5 T3 H}
}
6 S3 u$ G- z- E5 S6 a}

从文件中删除控制字符
- a1 P# F/ i7 T4 n" f5 w
/* This class removes control characters from a named
* file.
% v+ w/ H& M  X*/
import java.util.regex.*;
& Y0 Z; z4 t; j  d% Limport java.io.*;
6 b: b5 M9 u" ~! a6 @
, C' L: \; D6 e  mpublic class Control {
+ U$ w0 P- a! |public static void main(String[] args)
           throws Exception {
           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
; ~( }! b+ S3 g# N& z$ D% P* Q, `File fout = new File("fileName2");
//Open and input and output stream
: O1 B9 [- x  s: ~) G# }FileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
3 l% M3 k6 N  Q4 R. \4 @5 u
BufferedReader in = new BufferedReader(
; C' L  P: u; Y     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

1 L( l3 z: p7 I9 K// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
. c  L* ]7 e2 f* {7 C! r8 r& c/ T# aMatcher m = p.matcher("");
String aLine = null;
% M9 e7 g' V: i5 Owhile((aLine = in.readLine()) != null) {
m.reset(aLine);
2 g, [7 T5 |6 `4 t9 i! A8 @% I, Y//Replaces control characters with an empty
% h( t* x. w% f//string.
String result = m.replaceAll("");
; C, w; Y8 R- c4 i8 mout.write(result);
1 u7 Z( l, G: _" M1 @- T! p3 Bout.newLine();
' x& M5 K0 R9 ?* Z}
9 |4 s: n1 U+ a& Q+ N9 Nin.close();
9 \$ ~2 S3 N) d/ I  i" r% u/ Vout.close();
3 J+ Y/ R2 b0 T7 J7 ~1 I/ {}
& P' G0 k1 E1 M' U3 K2 w; a( f}

2 u, r- ^" x3 i% f8 r& r$ H文件查找
& C# F& ~: E+ P+ [4 n  ?
/*
* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
$ q' h# x" Y0 d" B- a9 Wimport java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
( j+ K" Q8 t# z5 F0 Lpublic static void main(String[] args) throws Exception {
9 G9 \8 h7 I. M3 |( o# I( h// Create a pattern to match comments
+ U# J! F$ j' U$ R" qPattern p =
9 T4 o0 A: y5 B$ S+ l" NPattern.compile("//.*$", Pattern.MULTILINE);
  q' _9 q/ {& A6 N: }& _+ t
/ G8 i6 n# ], Y- d) s// Get a Channel for the source file
File f = new File("Replacement.java");
2 J3 Z' n+ `- A0 B2 J/ mFileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
" B/ z6 S/ d8 u9 e5 u+ eByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
" m% H9 A  M) wCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
2 [" W* W1 l0 h( O! \( z* V
9 I/ E4 Q9 E4 G' k  f( L0 h// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
1 @3 B' v8 ^! PSystem.out.println("Found comment: "+m.group());
+ G: L/ y  s4 A# }* X7 R9 k}
+ f# r1 N& Z% }; o}

+ n8 W7 X+ B, s结论
3 g7 Y, X4 K  ]8 u3 O! G现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

. [3 j0 T7 w5 S, Y4 ?JDK1.4之正規表示式
; k5 ^+ _4 a" }2 H$ {0 m$ Pwritten by william chen(06/19/2002)
& ^/ Z  P0 r/ J4 v8 _' V: z* V
--------------------------------------------------------------------------------
% m. Q4 C. E1 j% k9 A8 r3 l+ f! ?
什麼是正規表示式呢(Reqular Expressions)

就是針對檔案、字串，透過一種很特別的表示式來作search與replace

7 L2 S) u8 t* B2 |2 G因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
$ \5 L+ L- x0 n5 n, ?( D
: v7 I# t& [- p: L$ \/ B* p所以發展出一種特殊的命令叫做正規表示式
* q6 W; x: e" |# l# c* |  m; S
) \% J, e# r, k1 N我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

5 f9 q1 G) D5 F3 `. Y0 C8 d若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

剛剛列出的一串符號" s/
' Q. `& V" S0 @) U8 t3 [: n適用於j2sdk1.4的正規語法

1 f0 y9 d7 |! Y& f8 [- Q"." 代表任何字元

正規式 原字串 符合之字串
. ab a
.. abc ab

) q! ?4 f3 j- C: B0 o7 T1 I"+" 代表一個或以個以上的字元
9 U6 v% x: F& @( G  M"*" 代表零個或是零個以上的字元

% \4 c) K# W: j% w" X& x正規式 原字串 符合之字串
+ ab ab
; \4 {& l; c! @1 x: ]5 `* abc abc

$ _2 I$ f& Z* S"( )"群組

) Z6 k+ t( ^- m) A: n! c正規式 原字串 符合之字串
. q: p5 N% g) c/ }$ D(ab)* aabab abab

字元類
$ Q& O& z& Y1 Z7 S% M% V& `. a
/ G" i1 Y6 v% z9 \* l6 A正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
# d0 ^7 ~' B2 W6 k* N- t[a-d]* abcdefgh abab
; z; @( p; `3 ?" ]
. G' Y5 Y$ D2 K- V& i
簡式

4 l2 @2 @8 K% \* h2 M5 r\d 等於 [0-9] 數字
1 A& [% J. {  G7 p% r! h0 r- u) \\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
- X; E. j. s- ~# ]\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

5 d* K) |8 O! Z3 G1 c^ 表示每行的開頭
% i" U% N9 }- j2 |( k$ 表示每行的結尾
& C7 T4 N3 P1 x) @
--------------------------------------------------------------------------------

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

Pattern—正規表示式的類別
) q8 g7 K5 ]# _- b5 a( `* K# `) {Matcher—經過正規化的結果
3 x7 o: G6 \+ I7 hPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
) b" _* b& p# k5 B' n. f* J
範例1: 將字串中所有符合"<"的字元取代成"lt;"
5 x5 S# D) Y, H
8 G7 I5 m8 B; I( x& \( X/ Himport java.io.*;
import java.util.regex.*;
0 ?6 q' h' V: z8 s3 w% w/**
* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
( p' I. i4 N- J// BufferedReader lets us read line-by-line
% S; C' d6 B: J9 Y" A) }/ ~6 XReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
5 m" M2 P$ U9 S6 u6 g9 wPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
5 s/ @* T  d% H" _+ B4 O) {) Ltry{
while (true) {
String line = br.readLine();
// Null line means input is exhausted
if (line==null)
break;
Matcher a = pattern.matcher(line);
while(a.find()){
System.out.println("搜尋到的字元是" + a.group());
0 Z- m& h: w; w: F' l}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
0 Z5 F$ K, b) G& q2 [: ~6 p  p}
}catch(Exception ex){ex.printStackTrace();};
}

範例2:

/ E$ V  Z3 T  b% _import java.io.*;
# {4 g- D) k5 N5 Z2 y) \( A/ zimport java.util.regex.*;
7 z8 L- }7 I( r+ m5 d; A/**
, P% B/ q0 Y. L* I- z* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
; _# ]" W9 }( }*/
2 T9 ^( l" v# T( Z% tpublic static void search01(){
// BufferedReader lets us read line-by-line
% f% k, H+ h' k2 E# A, j7 x; D3 kReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
try{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
, i% F2 O- S9 [! C- e4 N// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
1 W2 I% K2 i0 j1 G' Z" `int longest=-1;
int longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
longest = i;
longestLength = words.length();
' J" a8 [* n. K' N* \}
5 G. O& S2 d3 |8 _% ?2 d) g}
System.out.println( "長度最長為:" + words[longest] );
}
2 H5 l) ~9 d" X: w, D. \: A}catch(Exception ex){ex.printStackTrace();};
}
( w- I% x% `& H7 [$ F. l
. _6 g5 J% b* H! X. ~--------------------------------------------------------------------------------
8 B. \+ q$ F( b% S
其他的正規語法
. f6 w+ [# m8 q& n. ?5 M7 Q
/^\s* # 忽略每行開始的空白字元
' p( ^# ~  R/ ]* W3 z(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水