关于正则表达式---ZT

Longe

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

支持多种平台
& b1 g6 [* v* R; h( Y

! H5 [, t, v: f3 m% ?正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。
' l8 {  i0 p' k( V, G
正则表达式并非一门专用语言，但它可用于在一个文件或字符里查找和替代文本的一种标准。它具有两种标准：基本的正则表达式(BRE)，扩展的正则表达式(ERE)。ERE包括BRE功能和另外其它的概念。

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

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

正则表达式101
" Z$ M4 [  N' X$ `) ?很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。
) b' B6 Z* V7 }* A
第二部分：
----------------------
字符匹配
, j# u# a/ {6 x# F/ l: B! S
6 `/ L. |8 ?$ ]& x正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

8 q9 u7 B! Y8 P0 c# C  J- z; y+ S每一个表达式都包含需要查找的指令，如表A所示。

Table A: Character-matching regular expressions
7 _5 @* J# \6 E. ~# U格式说明：
( W# f# O$ r7 J+ }5 @- f; r---------------
8 O8 U9 v. n. k' k* [操作：
  t8 b& q. l9 |5 U- I% ^' w/ k" g解释：
例子：
0 {, P$ U  R& j( n* ^5 G结果：
, Y# `/ `# b1 Z0 Y7 C----------------
.
* P* o' A( ^8 o  |. XMatch any one character
grep .ord sample.txt
& i- O/ D1 a( T3 `Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
( |, x1 q" E& }1 e' M3 sMatch any one character listed between the brackets
grep [cng]ord sample.txt
: X+ L0 j7 s" @/ h2 A7 m( K6 G% MWill match only “cord”, “nord”, and “gord”
: r$ X5 l, O" J6 L7 u1 v; E/ D: y% w: g---------------------
  t7 X8 R0 f2 I& x2 M" P[^ ]
" o8 `3 W; j4 c5 Y0 `Match any one character not listed between the brackets

/ x5 s7 D  u9 }! U2 Mgrep [^cn]ord sample.txt
( C2 C2 q$ c/ {$ G7 E( D; TWill match “lord”, “2ord”, etc. but not “cord” or “nord”
/ ?& C8 A4 O7 \
4 M5 O* ]% h! h# k" Hgrep [a-zA-Z]ord sample.txt
Will match “aord”, “bord”, “Aord”, “Bord”, etc.
1 q9 H4 w/ s; k7 D
; q5 V$ v) n6 `* i; y! Jgrep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.
! o  @6 o8 j7 n
重复操作符
重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
6 @: P1 C+ k8 z8 ?, ^7 O
Table B: Regular expression repetition operators
& `! \4 K" h9 W8 v' f5 t' e格式说明：
---------------
# r+ L- _# j$ Z6 I+ u操作：
9 X9 G: k4 O% ^) D# Q2 K" c- \  ]解释：
例子：
结果：
----------------
- q* [- D) A8 U0 E5 E* X0 h2 L?
Match any character one time, if it exists
6 a$ L, Z7 a; b: n6 Q! _egrep “?erd” sample.txt
" |5 }, d5 ~* O0 z" [Will match “berd”, “herd”, etc. and “erd”
9 ?6 b# \( d5 p! p3 F6 U0 @------------------
*
Match declared element multiple times, if it exists
egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
2 j: _8 T# I$ q+
Match declared element one or more times
% n  `' |' k) w9 Jegrep “[n]+erd” sample.txt
. f1 J0 ]& i! W3 J" ~/ uWill match “nerd”, “nnerd”, etc., but not “erd”
--------------------
( V- X& \1 v; I) b{n}
; [4 Z+ L8 B! N  v1 Q" Z  g$ o/ n9 AMatch declared element exactly n times
egrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
4 g0 O3 Y$ B0 g, E' y$ y------------------------
" N0 [" A' \0 M2 |$ c{n,}
Match declared element at least n times
% F  {5 w: v- M7 ?% u, ^egrep “.{2,}erd” sample.txt
9 j) Z8 B) g2 `1 O/ [& r# n) J+ LWill match “cherd” and “buzzerd”, but not “nerd”
------------------------
{n,N}
2 m/ T0 y' c9 Z  y& h5 o% ^; A8 x! vMatch 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' P6 u: T  E----------------
- B+ `7 d! C3 s! n* r- `5 r9 D- y" t锚
2 a, s1 h" R9 y5 ]0 A) I锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
1 y- v* Q( m7 A2 w4 g+ i% B
; k: y* G6 M2 ds/pattern_to_match/pattern_to_substitute/
: t$ D& U5 I" G+ ]
  n6 l& X5 E' S- y+ S
Table C: Regular expression anchors
-------------
操作
解释
" @+ U2 f" l3 \- D例子
" a: M+ ?( ?4 D% [3 I" d8 _结果
0 _% P2 S+ s! O) ?1 J9 z* |8 X% v---------------
0 ?. o$ A/ u3 g6 [1 P6 V$ T, c; O^
# ~% j% X5 Q2 |Match at the beginning of a line
: D9 t4 [# V; e+ ^* \" zs/^/blah /
Inserts “blah “ at the beginning of the line
---------------
0 H  x& g2 e( s$
Match at the end of a line
s/$/ blah/
0 t; [3 D" k7 i3 ^# fInserts “ blah” at the end of the line
---------------
  s8 j" a8 p9 p/ h6 ?; n( g2 ~\<
Match at the beginning of a word
) f3 ]* w$ {: b3 F: N; o9 Js/\Inserts “blah” at the beginning of the word

egrep “\Matches “blahfield”, etc.
- ]( A3 p- {& O! t6 H4 K------------------
\>
Match at the end of a word
s/\>/blah/
2 c4 D1 H- \* V  m" q" PInserts “blah” at the end of the word

egrep “\>blah” sample.txt
; a0 L6 @# G% Z7 p% u- U2 x0 M6 aMatches “soupblah”, etc.
& y, N5 Y+ }. r2 O- {---------------
\b
; N, z6 w% P1 g' h. qMatch at the beginning or end of a word
egrep “\bblah” sample.txt
Matches “blahcake” and “countblah”
3 ~# y/ f- W% b# _- y-----------------
! Z- R8 H: {0 i+ V$ L7 B% O; f\B
Match in the middle of a word
egrep “\Bblah” sample.txt
2 ]# F5 t" Y) r; u" x5 ZMatches “sublahper”, etc.

( O- y5 R: _5 E0 l6 r4 \间隔
& x! W- W5 F  ?; `7 I
Res中的另一可便之处是间隔(或插入)符号。实际上，这一符号相当于一个OR语句并代表|符号。下面的语句返回文件sample.txt中的“nerd” 和 “merd”的句柄：

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

) Z- m. d; `- S% t间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：

% b$ D; C( a* w5 U) z9 K  k( Qegrep “[nm]erd” sample.txt

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

第四部分：
! \, w. N8 }6 r; n- O, F# X) p. k/ \) o) n- i----------------
一些保留字符
/ [% ~1 q" w! c. b0 q' o: zRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

^ (carat)
: M" [" S5 i+ n( W% Q8 r  R/ r. (period)
; h( c8 h6 [: e8 a[ (left bracket}
$ (dollar sign)
! ], M  o: a0 R5 `. C( (left parenthesis)
6 G2 P0 H( X+ ]7 ]3 C& u! E! g8 O) (right parenthesis)
4 m" m. v. z6 ~" a( K| (pipe)
! T  s. [" R3 c" \2 t/ v* (asterisk)
1 ]/ \5 @( C) v6 n: t8 x+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
1 B; O& F0 Q6 Z/ a: b\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。
/ V! y3 D, z) e
9 M. u7 P- b- \, c6 i& ]2 weregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)
2 [; T0 a) r5 [" m( f  w! A
你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。
) C: d1 S: U& z) b- |
5 n. ]# v( V$ O# G: ~1 @总结
$ n3 B4 s, n# B3 x, D在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
4 c3 w2 q. s6 @6 G; @
' }. e# N5 m( ]; |8 D% x' a另外一篇文章
1 M3 p% O. t/ M; g1 ?! H7 M' [----------------------------------------
1 h+ h, i" p6 w5 g4 M5 X4 B! {  J7 F正则表达式和Java编程语言
4 y: x1 I( D- R& z-----------------------------------------
类和方法

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

4 D" l, [% e5 K1 nPattern类
3 a2 ^' X6 |0 U/ t7 T
Pattern类的实例表示以字符串形式指定的正则表达式，其语 法类似于Perl所用的语法。
2 Q4 G' K$ }9 R% c0 n0 n4 l
# o+ S: b# i0 t) e用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
# Z4 z7 @  H4 s  {' V) S
' J& ?! N7 V. B  H9 n8 V( T用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
1 r  r( X9 w& k( M2 M& I- J3 ?
/*
* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
import java.util.regex.*;

public class Splitter {
public static void main(String[] args) throws Exception {
// Create a pattern to match breaks
6 }! Y, X% }- ^/ L" ^Pattern p = Pattern.compile("[,\\s]+");
4 Y, u/ k! f# y( |' @* B7 u// Split input with the pattern
String[] result =
   p.split("one,two, three four , five");
: Z( b) o3 n3 @; ifor (int i=0; iSystem.out.println(result);
- d; f9 o6 K4 q" v7 y1 R/ T}
}

* t/ ^% }7 Y% u* `Matcher类
( N+ p+ W9 I% _8 f9 }
. N- l! `$ A" o( LMatcher类的实例用于根据给定的字符串序列模式，对字符序 列进行匹配。使用CharSequence接口把输入提供给匹配器，以便 支持来自多种多样输入源的字符的匹配。
! O# }, x* B7 ^. U
通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法试图根据此模式，对整个输入序列进行匹配。
: y6 H+ Y! b+ x) B1 Q5 e4 qlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
: N$ \7 o: S& ], r
# c6 D% X# v! N8 ?% C这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息

这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

% o: X* p/ P5 p- HappendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。

7 T4 L6 ~/ j. D6 @( R7 l# u例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
; ^  U/ r4 A) o* B7 x
CharSequence接口
8 w  c& D2 |% C+ _0 h3 q0 k
2 g4 q) f$ X) H" tCharSequence接口为许多不同类型的字符序列提供了统一的只 读访问。你提供要从不同来源搜索的数据。用String, StringBuffer 和CharBuffer实现CharSequence,，这样就可以很 容易地从它们那里获得要搜索的数据。如果这些可用数据源没一个合适的，你可 以通过实现CharSequence接口，编写你自己的输入源。

# K0 y8 K$ r/ ~0 [* F7 \Regex情景范例

( \( z: U$ v' p# [: d以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：
. u) [! p4 M2 f, B
简单的单词替换
1 j: ]8 U! v. L# A& B1 C/ V
4 O* K0 q2 H9 [; n; x4 K/*
( p6 Q5 ]% Y5 @' \' k; I* This code writes "One dog, two dogs in the yard."
0 L2 x$ [. T6 ]+ z* to the standard-output stream:
*/
import java.util.regex.*;
% v0 G; t" Y- x
( V3 g0 y- P2 J5 A5 a) upublic class Replacement {
public static void main(String[] args)
4 x5 P3 n/ W8 U! v7 J% w* m       throws Exception {
8 S0 x* W5 E8 T+ l* |: B// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
     " two cats in the yard");
' O) D. F/ d# }3 U7 \StringBuffer sb = new StringBuffer();
6 r- |6 x# E8 ^8 _boolean result = m.find();
9 f- S# b+ X6 q% s( o* S// Loop through and create a new String
- v; d5 V2 y/ y& K- N// with the replacements
* _% @9 G9 Q+ v1 h6 O- P* `3 E" ?while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
m.appendTail(sb);
System.out.println(sb.toString());
}
}
$ B5 A5 r8 c. K6 f9 x) ~# z
电子邮件确认

0 M0 z: [0 S  I0 ^6 Q以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。
# U! H7 ^, J% [
) [# Q7 ]3 e. \  J' |+ U/*
* Checks for invalid characters
* in email addresses
*/
public class EmailValidation {
' d# V; H) c/ H  f9 |public static void main(String[] args)
; @  j" P) z- j7 ^5 [3 M5 o8 t3 n           throws Exception {
) N9 R/ D8 A3 f! T0 `( e& s           
String input = "@sun.com";
$ Y: H' u" W1 s6 W: u//Checks for email addresses starting with
//inappropriate symbols like dots or @ signs.
3 M1 h7 f4 h1 dPattern p = Pattern.compile("^\\.|^\\@");
4 J$ Z- J1 v: m3 g* qMatcher m = p.matcher(input);
if (m.find())
3 L1 Y+ \- W& F* m! K& ^) r" W  ?System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
' e$ m, U. x" p1 y//Checks for email addresses that start with
//www. and prints a message if it does.
; y  M" M8 k: [p = Pattern.compile("^www\\.");
& z  {" {% f% V4 \% F5 v3 O( @m = 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);
2 w  Z! _" t5 v2 }1 b9 |9 A( nStringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
; X- [1 Q" n: E8 N: {& a7 p
$ P& c3 `% Z$ y/ L( m/ s: w& mwhile(result) {
$ O$ T8 }, [  T( mdeletedIllegalChars = true;
& X# e# G6 i5 f0 ^" {8 u9 nm.appendReplacement(sb, "");
1 w% s* l9 X6 b8 rresult = m.find();
: b7 J  L1 @! J2 D$ J}
7 f: g% ^- {8 _% c# k. u* I1 t
4 K! \* t3 A  l/ ?// Add the last segment of input to the new String
& t1 g" L0 Q+ m# C( ~6 N5 m2 Bm.appendTail(sb);
9 h& l! E  k8 H  T1 }$ c
+ y  d8 S  x; U' [3 A6 P( k8 Ginput = sb.toString();
, G" `* @' l, }5 z6 J7 q
, G7 J; t8 ~; Hif (deletedIllegalChars) {
! @# i9 i0 v6 ]% ]9 m* L9 q7 wSystem.out.println("It contained incorrect characters" +
5 @+ ?; f+ y7 A       " , such as spaces or commas.");
}
}
" H6 X/ o. I: l% Q5 K}
2 |% \) c% v1 a6 X7 v& [
2 w; O3 c' k/ Q: X从文件中删除控制字符

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

public class Control {
* m  x+ J5 B# U$ l, Upublic static void main(String[] args)
           throws Exception {
6 ?( _3 @! Q2 G0 |  X           
//Create a file object with the file name
//in the argument:
" J  W1 \, m# b0 ?File fin = new File("fileName1");
+ y6 m& L4 i: f: y3 F. u8 aFile fout = new File("fileName2");
//Open and input and output stream
FileInputStream fis =
       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);

+ p7 A+ K, D& e5 {. j) Z# VBufferedReader in = new BufferedReader(
     new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter(
     new OutputStreamWriter(fos));

// The pattern matches control characters
1 n" P1 V/ v1 h! }Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
, J+ u+ [+ _0 q: ^) xString aLine = null;
1 K, z5 [% E" q' Lwhile((aLine = in.readLine()) != null) {
; c0 k- s" K% y: [4 ^# |0 |m.reset(aLine);
//Replaces control characters with an empty
, {2 s! J! X" y  i  a6 N//string.
String result = m.replaceAll("");
) {; _7 }* E% eout.write(result);
# n/ P' y" ?/ Tout.newLine();
}
in.close();
out.close();
}
+ x( J! |# I$ u1 n}

1 k+ L; l4 [' w  d0 G. e文件查找

: M3 c! w. `  h/*
) _4 {: v  f9 h% E- P) O* Prints out the comments found in a .java file.
*/
  K1 i! M5 ^- T1 mimport java.util.regex.*;
/ [7 N" v$ [: E- d. O/ H4 o+ ?9 eimport java.io.*;
import java.nio.*;
import java.nio.charset.*;
+ b' Y2 B1 B+ U) B5 O( \, `# ]import java.nio.channels.*;

public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
) m% z$ p, ~9 f6 ]) EPattern p =
2 h& |, n1 y& i- U% J9 TPattern.compile("//.*$", Pattern.MULTILINE);
/ B& T7 O/ W( [! T" Y' L
5 s$ ~: j( O9 ^0 Q* @7 {// Get a Channel for the source file
File f = new File("Replacement.java");
; i* C  m) z$ v; DFileInputStream fis = new FileInputStream(f);
3 O7 s  U! J. x  ?2 ^, DFileChannel fc = fis.getChannel();

; x) N3 ?) ?2 f8 _// Get a CharBuffer from the source file
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
8 U- @2 y1 j7 d) ~CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
8 {4 T" }6 g7 h$ P0 Q" s7 ?
// Run some matches
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
4 B7 q' q8 k( U1 v3 {4 Y) q6 L}
5 ^, G. d: l# n2 y) m: c8 I
& n$ I# C# }  H0 Z( D. r+ s: F结论
* C' h& _5 D5 v, T+ T8 K现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。
0 y& P$ R  S! Z) _& f/ z2 W; i
JDK1.4之正規表示式
& u+ B  D" m$ \: d( D9 `written by william chen(06/19/2002)
. ~5 ]1 ^( w; ?
--------------------------------------------------------------------------------
+ r  U: }8 K# u/ m6 G) P( o' P7 Z5 x
  S$ Y5 V& p9 l7 L" K5 ^什麼是正規表示式呢(Reqular Expressions)

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

: [' b+ G/ u) g( t因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
8 o& A2 d; }2 D" C
所以發展出一種特殊的命令叫做正規表示式

我們可以很簡單的用 "s/
0 G. |# D" R8 U# K; k因此jdk1.4提供了一組正規表示式的package供大家使用
8 y' B5 m7 R2 I% C% ~$ ~) F
2 |9 u& i2 U. Q3 D$ h若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
2 P. A' v6 ~# s/ v0 E2 e
: U0 O) e  l4 f3 p" C, q, w剛剛列出的一串符號" s/
適用於j2sdk1.4的正規語法
9 B& b: S; ^! P, X% ~4 P* D3 Z. k" v
"." 代表任何字元
+ C+ b- n) n: i' a
2 N/ Q' z2 H$ c# @- ?+ s: Z正規式 原字串 符合之字串
: d  Y! H/ }5 K0 X. ab a
.. abc ab

"+" 代表一個或以個以上的字元
"*" 代表零個或是零個以上的字元
, ^3 Z& m4 n* q& F9 [/ i
" H6 k  U3 H" i正規式 原字串 符合之字串
+ ab ab
5 \* e2 q6 f: z. B3 y* abc abc
: E: g3 `( s5 G. A) c
/ r8 `" z& d% R4 T6 i' p. S; n"( )"群組
) d: h' }) K$ e5 u% K
; |% {7 T- L5 S. J3 C5 d$ e! J) U正規式 原字串 符合之字串
(ab)* aabab abab
# _' t9 O; \8 h0 S+ ], Y
2 L" a" o) i/ a0 w7 [$ i; q字元類

- s- R# H3 J. k; f! R6 Q  v正規式 原字串 符合之字串
( h: k' F  }. C: E/ H! c* C$ [[a-dA-D0-9]* abczA0 abcA0
& n( k) J, e" o[^a-d]* abe0 e0
[a-d]* abcdefgh abab

8 E) c4 ]; c4 U3 A* p) b8 _
簡式

, j* O0 ~4 k7 z2 B3 j\d 等於 [0-9] 數字
7 N: [! [$ ^' m- N! F\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
" ]! u# H2 f4 i) Q7 }- G\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

每一行的開頭或結尾

8 ~" D' N9 W, f- f# P! @9 T^ 表示每行的開頭
$ 表示每行的結尾

3 T; ~5 z% p8 ^% N. u--------------------------------------------------------------------------------
* h' Z( C+ L/ }0 }
. i* J* U' s0 @# z4 x: D正規表示式 java.util.regex 相關的類別

Pattern—正規表示式的類別
Matcher—經過正規化的結果
. y2 e$ J; m: m; ^" x7 ?8 KPatternSyntaxExpression—Exception thrown while attempting to compile a regular expression

4 Q8 _" f' A) l6 C1 e8 [* F範例1: 將字串中所有符合"<"的字元取代成"lt;"
3 d8 F5 M; d- @& v
import java.io.*;
: a9 s  D; y/ s; Kimport java.util.regex.*;
/**
" u& \# e6 x7 j# s0 z* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
) H( V# d* x6 }% v0 _( P% n, K// BufferedReader lets us read line-by-line
, z: `: s0 f4 x" {- [4 Z6 D  {$ HReader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
try{
while (true) {
. b" v0 x* d0 `- _- KString line = br.readLine();
// Null line means input is exhausted
, @" S0 d$ `7 B, ?6 fif (line==null)
break;
Matcher a = pattern.matcher(line);
, f* A0 r8 l& L: ?2 E& fwhile(a.find()){
System.out.println("搜尋到的字元是" + a.group());
! Z8 Z& V- S2 @. J, C- e}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
7 B9 L3 O7 L: G" z8 F* O}
9 ?. D6 M# d# k4 H8 e7 Y' U4 G
範例2:

import java.io.*;
import java.util.regex.*;
5 T9 h& i' G# d9 ?/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
' P2 R1 A0 B- Z9 H7 ^6 a5 y9 T, c*/
public static void search01(){
! U9 h6 d, z8 u  ~6 e5 j. }2 F// BufferedReader lets us read line-by-line
; r; R* F! V  h5 N5 b3 t+ [3 iReader r = new InputStreamReader( System.in );
2 J7 j% {9 g" p7 ^" _BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
1 s' A6 C8 ]1 a) V' [3 F/ B1 rtry{
while (true) {
String line = br.readLine();
3 C% m+ \/ @% R' }0 {String words[] = pattern.split(line);
- E5 C) `5 e  K! l7 \// Null line means input is exhausted
if (line==null)
break;
7 x6 S, h8 f' Y( `0 h* Y; [! @/ J// -1 means we haven't found a word yet
6 \- Y0 {. i' x2 F0 z5 c; {: ~int longest=-1;
5 I5 J9 t- e0 j& Oint longestLength=0;
for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
longest = i;
+ e; i, T2 u3 llongestLength = words.length();
}
}
System.out.println( "長度最長為:" + words[longest] );
/ _+ A6 _  c# \9 t/ G}
1 S1 q' b( n7 E* v/ P3 @1 N}catch(Exception ex){ex.printStackTrace();};
}

& e$ i! P2 N) B! T+ `7 y--------------------------------------------------------------------------------

: }% a& Y. ^# x5 M! n+ l% J% ?其他的正規語法

/^\s* # 忽略每行開始的空白字元
% c  a/ J7 f1 R( S0 i. x(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水