关于正则表达式---ZT

Longe

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

支持多种平台
2 V9 Y) _; f1 ?1 \
. Z, h/ @% U! J/ A& J, a' T
8 G" C# y% z; @) z0 i正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

# B2 U# e/ h- k7 {% {正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

+ O7 V- b% D/ A) P( W6 O& l许多程序中都使用了正则表达式，包括xsh,egrep,sed,vi以及在UNIX平台下的程序。它们可以被很多语言采纳，如HTML 和XML，这些采纳通常只是整个标准的一个子集。

比你想象的还要普通
* F7 O" Q" J7 k/ U( g; N  S6 ~随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。

$ I2 P( G/ q$ m9 l. H4 w# J正则表达式101
6 e- E- D1 s8 Q! D很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
$ ?  @. d3 c: g! z  u( e
第二部分：
  e0 |1 S) s) m$ f3 C----------------------
字符匹配
( U6 n/ v  o9 K: T0 Z2 P% D
0 D$ {8 r( a  w6 t8 \. |1 q" g8 v' K正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

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

) _/ }6 }' y$ T" OTable A: Character-matching regular expressions
格式说明：
---------------
操作：
解释：
例子：
结果：
( D) J; `: F  K6 q1 K' e9 u6 w+ k----------------
.
; d8 M/ x+ l* g9 ^2 G. }" gMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
9 E* J* l. i9 Y$ }7 lMatch any one character listed between the brackets
- q! ?0 \0 P% F7 |grep [cng]ord sample.txt
8 ~/ s# @' l% O+ \. ~  |% P& @! QWill match only “cord”, “nord”, and “gord”
---------------------
[^ ]
4 D' ^5 ^5 Q: C  z# d" r. tMatch any one character not listed between the brackets
; F% m9 X( u/ g
0 Y( w. ~; w+ P2 ], o# e) \' Kgrep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
0 ]* p6 B$ F9 g% J6 n
grep [a-zA-Z]ord sample.txt
- p# ~- d8 f  X! m+ vWill match “aord”, “bord”, “Aord”, “Bord”, etc.
- w% Y# P9 M7 L: a" d9 M6 p( J' T
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
" H7 H7 f; u$ M# H( m重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。

Table B: Regular expression repetition operators
8 _$ E/ a: [5 A) M! i* D格式说明：
---------------
操作：
. N3 [. @4 e! g* v5 Z2 b解释：
! }! P% m+ D- f1 H例子：
结果：
----------------
3 U3 G/ G' H2 L* U! X; x?
- G* [# q' X% oMatch any character one time, if it exists
' T" i- [- Q6 G. H3 p* u4 yegrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
. h: ?( e& s  [5 o9 o7 s- b6 a# x" @------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
* R- B) C1 f. m1 Z1 ^! n+
% ?: t: l& \9 E* A/ U' `0 |0 XMatch declared element one or more times
4 z6 ]* Y# T. H& K7 |0 b4 eegrep “[n]+erd” sample.txt
Will match “nerd”, “nnerd”, etc., but not “erd”
' d8 T3 l6 {& S3 n3 s, L- D2 G--------------------
+ S% m& ]7 c  R; A* @' y7 {{n}
Match declared element exactly n times
1 e* O) V2 q( d* h& Segrep “[a-z]{2}erd” sample.txt
3 @' K  i: t5 J6 y! K4 J7 ^Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
% Q* N1 Y2 p1 r3 u8 p{n,}
. z# r( w- A, s% GMatch declared element at least n times
* [5 O" J4 x9 T- xegrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
/ e; \6 X' E  E------------------------
{n,N}
Match declared element at least n times, but not more than N times
: Y' t& H% Y9 B, Aegrep “n[e]{1,2}rd” sample.txt
) Z2 z% I  I& P5 k/ K0 \8 PWill match “nerd” and “neerd”

, P+ Y+ Y$ T( a5 k第三部分：
----------------
锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
$ ~2 j* p. M4 Z  q1 Q* N' Q
s/pattern_to_match/pattern_to_substitute/
% k3 |! O* N2 }! n! ^/ }
( [/ G) w6 r. g2 W( j1 }5 I) T
Table C: Regular expression anchors
9 U1 |  ?1 j5 x6 Y  Z9 C3 L1 a9 `* G-------------
% W# [" y; [  {& b操作
8 h  w* |5 B# b/ J5 z, H; T) o解释
1 _9 u! m7 s4 v% L8 v( W例子
结果
5 S+ v& x" G; i' j4 l5 H---------------
) ~- {! {( L: u9 w& m5 {: N^
/ P9 d. P! y3 p% n2 }5 k* F% S; q& _Match at the beginning of a line
$ k: B# }5 x' c5 N3 ls/^/blah /
/ m( ?4 I4 x4 ]% ~2 K9 ?& m& pInserts “blah “ at the beginning of the line
---------------
$
) ]9 z) u6 a, a( d; R) CMatch at the end of a line
( G" `3 ?/ M" N0 j- b) us/$/ blah/
Inserts “ blah” at the end of the line
---------------
2 y6 E; a! i, w, H  B5 k# V\<
& P4 A3 r* O3 i( U# t- }Match at the beginning of a word
9 P9 Y+ V. j7 M: ]7 Ls/\Inserts “blah” at the beginning of the word

$ `* \0 I' s8 I1 o/ ^, b! Degrep “\Matches “blahfield”, etc.
) ?0 W( ?) z6 Y% @0 y9 q------------------
\>
Match at the end of a word
s/\>/blah/
- y7 J3 a3 z" ^7 k, I+ Z# ^8 P: VInserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
\b
. Y( M- P1 `% ~- C  ZMatch at the beginning or end of a word
5 w" X6 x- ]/ Z1 }egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
-----------------
\B
Match in the middle of a word
2 {- x6 i" f; u0 \# s( hegrep “\Bblah” sample.txt
6 Q( ?  {& ~: u# I+ e* @- cMatches “sublahper”, etc.

间隔

Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：
; }" e2 V& A3 e( q, u! D
; l/ g- Z" V0 q/ i* ]7 R8 R1 xegrep “(n|m)erd” sample.txt
& J: A% O" P$ A( u- w+ x9 c
间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

egrep “[nm]erd” sample.txt

6 {2 `4 [, n, E! \$ Y+ H. c* ?当你使用间隔功能与Res的高级特性连接在一起时，它的真正用处更能体现出来。

" V5 m( \: t- z; c5 N! ~* T) G. ~第四部分：
# H/ y( o! W& M% d5 W$ a2 S----------------
一些保留字符
Res的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：
3 N  N0 A  D, u% t* F( A: D2 _
# }  n7 o: O4 R: j4 `. H4 y8 v^ (carat)
. (period)
3 k: D' y. I  s2 O0 ]4 A[ (left bracket}
$ (dollar sign)
( (left parenthesis)
" L7 ]3 _- S: X" V* @) (right parenthesis)
  {$ D( N# Y- l  r: \* [0 I| (pipe)
* (asterisk)
# M  ~0 l+ T  j! b! l+ (plus symbol)
? (question mark)
; W3 g6 U( ~8 t: I8 L9 N1 Q{ (left curly bracket, or left brace)
\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

9 \1 M; R( O! c2 v: o9 Ieregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
" H0 }1 m# c0 V" V- m
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

+ U; p, j0 ~6 ~" P  V2 H# e/ f, j总结
& n9 @+ S; V1 m" W$ W在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
: o' B. I' |" @: s& L5 {' O1 l! j
4 m% k' y/ w6 j" o另外一篇文章
2 Z2 |' @, [9 }) l----------------------------------------
正则表达式和Java编程语言
-----------------------------------------
, v& H9 {3 j$ E" W类和方法

下面的类根据正则表达式指定的模式，与字符序列进行匹配。

Pattern类
5 P3 n) ~- f; k3 S5 x
+ R1 L- g7 O( ?Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
0 Z. D0 s+ g! A$ g$ J
7 R- O3 |. ~0 t1 q8 m/ E用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

2 s5 X0 D8 Q9 }5 B用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。
# A+ d+ M: x/ O5 l3 Z! S
split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：

/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
( n  p& ]6 V7 G* Q  h; Z*/
import java.util.regex.*;

( V3 r- E) t  i. ?8 O8 C" K, Opublic class Splitter {
$ y) @0 a) x: v# y5 c$ x4 ipublic static void main(String[] args) throws Exception {
// Create a pattern to match breaks
" F( u$ [+ C/ VPattern p = Pattern.compile("[,\\s]+");
# h7 p% Q3 @' ^! Z" l// Split input with the pattern
String[] result =
5 L+ N( n2 ~7 `  O6 e   p.split("one,two, three four , five");
for (int i=0; iSystem.out.println(result);
6 k* T6 j' x9 I( z- y6 m, a4 z! T}
- k: M1 f% N) e( Q. s}
) q6 H$ i) Q- S9 t9 W0 X, S
' F* A( K) o3 a9 aMatcher类
6 c4 q0 T+ ]7 m8 h! o
Matcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
+ Q% B( A" _5 }0 F5 j
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
9 k9 m/ R& @" o5 u! C. G. b
5 E: ^: H6 O8 K- cmatches方法试图根据此模式，对整个输入序列进行匹配。
lookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。

# X& \0 H7 E1 p9 d; a, l/ `; ~5 E这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
# R; O5 @' E) ^2 [
- y3 Z+ _' R8 s, P1 O这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。
: v; u8 e& e% O- ^
+ E. h) q) D+ M9 q& VappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

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

CharSequence接口

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

Regex情景范例
" t- ^+ t2 d8 O9 E: P
0 r& I4 z( g2 M0 F0 V0 X以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
% a# w' Q$ W& S
6 W4 F% Q3 t% |3 X1 Y$ K简单的单词替换
5 d' Y4 o" ~5 ~- B1 `& ^' O8 G
/*
4 @# T  m9 v! ?* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
3 h0 T5 W: I1 Z) S# u*/
* T$ S  T$ ?( T6 L8 h2 m- Aimport java.util.regex.*;

public class Replacement {
. ~% v- }8 b# Q* `9 y/ E" a) d% tpublic static void main(String[] args)
       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
. C! o+ B( T# T6 |, L/ W$ I+ t/ ]// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
  ^' E6 x' O* w! a     " two cats in the yard");
StringBuffer sb = new StringBuffer();
  k1 q! {% z4 z2 dboolean result = m.find();
// Loop through and create a new String
// with the replacements
; J2 }/ C, s- ^0 Lwhile(result) {
9 ]' N- M3 E. S3 A- jm.appendReplacement(sb, "dog");
0 q# X2 r. J; g$ c3 |result = m.find();
8 w- `( E* ?, \}
// Add the last segment of input to
9 z5 J5 k9 P9 M$ a& [; Q0 ~: x2 Y7 B// the new String
m.appendTail(sb);
System.out.println(sb.toString());
}
}
! j& U: o* z8 G6 O1 e* e
. }1 f$ S% @. }电子邮件确认
$ e5 }% I5 ?( r% l  W8 L
. _2 y) q8 E, Y  ]. c以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
: ?: Z" v( e% v- `: X
/*
* Checks for invalid characters
& f# A- b% a  C' M* in email addresses
5 v0 A! `9 m& F8 x/ u/ o9 K*/
public class EmailValidation {
public static void main(String[] args)
( H' U% F9 D: w9 ~1 `% r. Q           throws Exception {
           
- B8 @6 E: s: Z7 ]6 O7 S* _String input = "@sun.com";
//Checks for email addresses starting with
9 k7 {! O* d& ]8 Y//inappropriate symbols like dots or @ signs.
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
: q9 I5 F/ B& Z, Aif (m.find())
System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
# X4 k. U  M% G//Checks for email addresses that start with
8 k% g& d9 J7 S0 S, i& s# C, v) e//www. and prints a message if it does.
* [5 T$ `+ m2 I- x( vp = Pattern.compile("^www\\.");
m = p.matcher(input);
/ d' Y5 U' d" I& B8 ~# i  n% Oif (m.find()) {
System.out.println("Email addresses don't start" +
   " with \"www.\", only web pages do.");
}
  F9 y. `6 Q6 U( `; u, L( d  yp = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
" {2 A3 a! k6 H9 ?' }0 PStringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;

while(result) {
; D/ l! ?% p+ ?, s+ j( ^2 sdeletedIllegalChars = true;
, G( t$ n# L3 I4 [% q/ }" ^; om.appendReplacement(sb, "");
result = m.find();
}

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

input = sb.toString();
" Z" H0 C  K1 a) H
if (deletedIllegalChars) {
  ?' {$ I- A* d2 ~, NSystem.out.println("It contained incorrect characters" +
6 y# V4 N7 e& a  ^       " , such as spaces or commas.");
}
}
}
" l: a' j' Z+ d( x1 J
从文件中删除控制字符

' h2 |+ J3 f4 W& [. d% d" C/* This class removes control characters from a named
* file.
8 S4 f) C8 v7 s7 P4 [$ S/ A*/
import java.util.regex.*;
" c: J5 P" P9 l7 R3 jimport java.io.*;

% v0 I& V: P% [4 l' H3 Y7 r3 ?- X) m- wpublic class Control {
public static void main(String[] args)
           throws Exception {
7 r% a" P' m, I! m           
//Create a file object with the file name
//in the argument:
; _: \0 D2 f5 Q. }7 s& l5 T4 J  L0 HFile fin = new File("fileName1");
File fout = new File("fileName2");
3 b) v" d7 c, b. f' A8 U, D//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
) F6 l7 m4 x6 D$ z  YFileOutputStream fos =
$ h- R( j# U& E) P3 x       new FileOutputStream(fout);

8 d+ ^* R9 Y! ?BufferedReader in = new BufferedReader(
) _0 O# r8 G* `1 h- A; {3 K     new InputStreamReader(fis));
% l/ s& I  U4 `- d  G# PBufferedWriter out = new BufferedWriter(
( B$ _4 L7 U- c  P% w! K     new OutputStreamWriter(fos));
% N$ a1 @% _  b5 l  q. B
) h% Y# p& D6 y- n// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
, x5 z- A/ q8 T6 n4 t! z) AString aLine = null;
, b5 a+ K3 b& c8 z0 j/ rwhile((aLine = in.readLine()) != null) {
; Z6 C5 w3 f! km.reset(aLine);
//Replaces control characters with an empty
//string.
& S* p% S8 M3 t3 a2 ?String result = m.replaceAll("");
$ [! n- M0 R6 \2 Gout.write(result);
out.newLine();
}
in.close();
+ V& U! l; }9 h5 N. @, Jout.close();
}
}

文件查找

/*
* Prints out the comments found in a .java file.
7 [9 C' I- q5 }, k*/
import java.util.regex.*;
5 d2 ~- _; t1 |' L* ^; Simport java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
: r0 f2 |: V1 {0 {
public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
" a3 ?  @7 ?" n$ oPattern.compile("//.*$", Pattern.MULTILINE);

1 I% H( g: a4 X2 r# _// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
& a* x; M3 w8 |0 kFileChannel 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);

- k7 T; X9 n& O# P; p  s// Run some matches
Matcher m = p.matcher(cb);
/ `+ r0 d& b; [( }, q( G, _. wwhile (m.find())
System.out.println("Found comment: "+m.group());
+ t( f4 Q8 `! s8 c}
}

结论
2 Z, m; @! W2 M/ b现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
+ K& B6 n- v& c  a+ P6 |* I
) M  A' d  c5 K: S- z6 rJDK1.4之正規表示式
4 H1 T1 p$ V" Z0 m+ R" hwritten by william chen(06/19/2002)

, Z8 A, j, y2 E* ]" Q6 o% H--------------------------------------------------------------------------------
7 |  z" ?$ L1 B" \* |+ P  I
什麼是正規表示式呢(Reqular Expressions)
4 D$ p. n- R2 A) v
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
; }3 D' g' k3 O0 k
因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
! N( k* M3 g  x6 Q5 }
" \* F$ @( N8 n& L所以發展出一種特殊的命令叫做正規表示式
" O  N6 H  L! @  h- Y7 G; r& N
我們可以很簡單的用 "s/
因此jdk1.4提供了一組正規表示式的package供大家使用

若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package

! |0 v1 X5 P, Q+ ^. H' y剛剛列出的一串符號" s/
7 ]7 f$ p' |& k5 o7 o適用於j2sdk1.4的正規語法

"." 代表任何字元
2 D8 d$ T( v- N9 I
8 M6 J9 @& f; [: Q4 z正規式 原字串 符合之字串
. ab a
.. abc ab

. A3 Q0 \  v; D"+" 代表一個或以個以上的字元
4 S# k& F5 i; m. ?"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
+ ab ab
4 O8 a' z: Q0 E5 g" |2 }* abc abc
. o8 P( w& k1 ]6 I
"( )"群組

* \/ {; W7 f/ Y6 M6 A! v: t正規式 原字串 符合之字串
2 Z7 R7 \* D& r' r- R(ab)* aabab abab
. a( K) w, K0 r9 Y: T
, U3 n2 w# @1 v' z字元類

正規式 原字串 符合之字串
[a-dA-D0-9]* abczA0 abcA0
[^a-d]* abe0 e0
" p6 n) w/ g3 ^  b  V: `[a-d]* abcdefgh abab


簡式

) j( l/ z0 ?9 \% {: L5 }3 T\d 等於 [0-9] 數字
; x* ]0 m8 ^/ n4 T$ h- {\D 等於 [^0-9] 非數字
/ S( S# K, ]5 H) o\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
9 m1 B5 _, q6 @2 ~\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字
: q6 I' C" q0 {; C: @6 r- b5 o5 V& z- W
( j$ K3 A& S/ X4 ^每一行的開頭或結尾

( O5 I( n( w3 r- u+ R# c^ 表示每行的開頭
( }5 s% n& \8 p; g. M, J$ 表示每行的結尾
1 P! _. X. b9 `  @
: n# v6 W  c" k; O--------------------------------------------------------------------------------
- x! g* n. X+ J9 \6 K  t
正規表示式 java.util.regex 相關的類別
8 |% K2 Q4 [( }
Pattern—正規表示式的類別
; k2 k+ W+ o2 `6 k2 y' F' m% A: m4 XMatcher—經過正規化的結果
) n, e7 l) p( |" x3 H, _$ cPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
; _! K4 F. R) D1 s0 E: W
) h1 T. t1 L' M7 l8 }! b- g6 r1 r範例1: 將字串中所有符合"<"的字元取代成"lt;"

, K5 e/ l/ e7 U" ?; v8 z  eimport java.io.*;
import java.util.regex.*;
/**
; R1 Z. }' }7 v. ^- Z7 C: @  \* 將字串中所有符合"<"的字元取代成"lt;"
3 A+ s( D& X1 `$ @4 Q*/
# Q2 s- {# }% x* C* Gpublic static void replace01(){
( T' Z4 ?& o2 U( V! g; b$ b// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
, E  |, ?; @! V- Y: f, N2 L  GBufferedReader br = new BufferedReader( r );
9 V; _2 e6 l) T3 SPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
' g2 s+ v. |& `0 G- W$ n% Rtry{
while (true) {
8 w; y( @3 N2 m- t0 GString line = br.readLine();
  Y" k$ E1 \* F! _// Null line means input is exhausted
if (line==null)
break;
2 \$ k" |7 Q) v. S8 K+ N. RMatcher a = pattern.matcher(line);
while(a.find()){
+ l7 i7 D8 _( j9 `System.out.println("搜尋到的字元是" + a.group());
, }8 g9 {/ V8 h2 H  @4 {$ H6 }% d}
( j4 f5 l& l. }/ uSystem.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
}
8 [' i5 V# ]5 }$ k
範例2:
/ t" X, c  X+ X  e
$ D5 ~; \  o) y9 V, Z2 vimport java.io.*;
import java.util.regex.*;
/**
5 f1 j: w, i0 l) T: [- q6 G9 Z* 類似StringTokenizer的功能
( t2 V5 f' f8 M7 F* 將字串以","分隔然後比對哪個token最長
*/
public static void search01(){
# M2 b$ L* y, R, F5 S& P// BufferedReader lets us read line-by-line
Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
4 Q$ y/ V: Z& ^  _/ ktry{
while (true) {
/ ?& y! A2 h0 H( r& w! n' _String line = br.readLine();
String words[] = pattern.split(line);
// Null line means input is exhausted
if (line==null)
1 k! p9 V. v- J7 sbreak;
// -1 means we haven't found a word yet
: x$ K) ~! l+ gint longest=-1;
int longestLength=0;
7 V: F4 n% N: F$ p# z. a! \0 tfor (int i=0; iSystem.out.println("分段:" + words );
, w6 Q% t$ d" ^2 x5 Eif (words.length() > longestLength) {
! _: y! o* X$ F; {, X. U8 H0 B& W$ llongest = i;
longestLength = words.length();
}
}
# a6 P) n, i  ^% h, `% _! ~2 `System.out.println( "長度最長為:" + words[longest] );
  p  Y% M2 _1 S" x4 S- C) K}
* F) j6 }$ H7 |, i* @! b3 L8 k}catch(Exception ex){ex.printStackTrace();};
}
0 y4 L# D& v; v1 ^+ W
2 M+ h- P- [0 |( x! T--------------------------------------------------------------------------------
% K* Y3 k& C2 O
其他的正規語法

( g3 |; A/ Z7 Y3 q1 `/^\s* # 忽略每行開始的空白字元
(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水