关于正则表达式---ZT

Longe

第一部分：
-----------------
8 n" ~& o% g# Y- ?: h) ^# ]1 ^正则表达式(REs)通常被错误地认为是只有少数人理解的一种神秘语言。在表面上它们确实看起来杂乱无章，如果你不知道它的语法，那么它的代码在你眼里只是一堆文字垃圾而已。实际上，正则表达式是非常简单并且可以被理解。读完这篇文章后，你将会通晓正则表达式的通用语法。
1 A5 c- {3 @/ y* ^& f# y0 F
支持多种平台


) g, R+ w+ L; Y; X1 e6 b1 k  I* D正则表达式最早是由数学家Stephen Kleene于1956年提出，他是在对自然语言的递增研究成果的基础上提出来的。具有完整语法的正则表达式使用在字符的格式匹配方面上，后来被应用到熔融信息技术领域。自从那时起，正则表达式经过几个时期的发展，现在的标准已经被ISO(国际标准组织)批准和被Open Group组织认定。

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

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

% D8 @: \- ~  U" T比你想象的还要普通
  w6 W1 s) q! e% d  E随着正则表达式移植到交叉平台的程序语言的发展，这的功能也日益完整，使用也逐渐广泛。网络上的搜索引擎使用它，e-mail程序也使用它，即使你不是一个UNIX程序员，你也可以使用规则语言来简化你的程序而缩短你的开发时间。
0 C6 Z1 o- S" F7 p- B5 s6 d4 j- P
正则表达式101
很多正则表达式的语法看起来很相似，这是因为你以前你没有研究过它们。通配符是RE的一个结构类型，即重复操作。让我们先看一看ERE标准的最通用的基本语法类型。为了能够提供具有特定用途的范例，我将使用几个不同的程序。

第二部分：
----------------------
3 d% @$ M; A! {" r. c7 U: f9 Z字符匹配

正则表达式的关键之处在于确定你要搜索匹配的东西，如果没有这一概念，Res将毫无用处。

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

Table A: Character-matching regular expressions
, W  \9 F( ~/ g8 l& j: n格式说明：
---------------
0 E( |: d* C& p" u5 O  V操作：
! Q- R0 h; n; j+ h6 {6 y解释：
; m  C1 s0 `- V8 f7 r例子：
% @/ S" T, J, f( r% K结果：
----------------
.
! r) j6 V3 ^' T: g; sMatch any one character
grep .ord sample.txt
Will match “ford”, “lord”, “2ord”, etc. in the file sample.txt.
-----------------
[ ]
Match any one character listed between the brackets
- m' G1 \+ ~3 T/ Z( e  c4 P( ?grep [cng]ord sample.txt
Will match only “cord”, “nord”, and “gord”
---------------------
( Y# Q6 U# I$ x. {* U( N[^ ]
4 {. s8 r" ?$ M6 ]9 }7 B2 iMatch any one character not listed between the brackets
; c. f# v; V5 H5 \
grep [^cn]ord sample.txt
Will match “lord”, “2ord”, etc. but not “cord” or “nord”
! G" Z+ m- @* ?8 R% W
grep [a-zA-Z]ord sample.txt
- i/ ^$ \  S% C: IWill match “aord”, “bord”, “Aord”, “Bord”, etc.
  g' E# M( i/ D' l! b6 C- N$ d; I
grep [^0-9]ord sample.txt
Will match “Aord”, “aord”, etc. but not “2ord”, etc.

重复操作符
: _4 O  W: J: ]- x: ]重复操作符，或数量词，都描述了查找一个特定字符的次数。它们常被用于字符匹配语法以查找多行的字符，可参见表B。
/ t" i* {# ?$ D3 I7 k: ^& A
Table B: Regular expression repetition operators
格式说明：
& L5 a) T' N4 @  l- e$ p' ~---------------
操作：
解释：
例子：
' g/ U3 S" Q$ T! \% y2 I5 V4 i结果：
----------------
6 ~. S2 o7 V3 w, V0 d?
Match any character one time, if it exists
egrep “?erd” sample.txt
Will match “berd”, “herd”, etc. and “erd”
------------------
( e8 K( q1 e- V/ \*
Match declared element multiple times, if it exists
. u. L- b3 }2 [egrep “n.*rd” sample.txt
Will match “nerd”, “nrd”, “neard”, etc.
-------------------
) A- ]+ F8 `8 Z) S$ q+
0 T# R/ y* s5 q5 ]9 h. Q0 @Match declared element one or more times
& ~+ M( @/ x& J9 A1 x" `egrep “[n]+erd” sample.txt
& S& X6 I/ ]* B) Y* q# RWill match “nerd”, “nnerd”, etc., but not “erd”
6 {7 R0 A1 s) d' H9 f--------------------
, Y9 a' g9 Y$ p3 f/ |{n}
Match declared element exactly n times
9 |' `7 d: T2 ^+ L, Vegrep “[a-z]{2}erd” sample.txt
Will match “cherd”, “blerd”, etc. but not “nerd”, “erd”, “buzzerd”, etc.
------------------------
{n,}
9 t  y. U# }' U8 fMatch declared element at least n times
egrep “.{2,}erd” sample.txt
Will match “cherd” and “buzzerd”, but not “nerd”
------------------------
$ i% A& ?: S' o6 t$ w% e4 H* t{n,N}
Match declared element at least n times, but not more than N times
egrep “n[e]{1,2}rd” sample.txt
/ i: W, [) W8 e8 ]8 T+ v, Q+ tWill match “nerd” and “neerd”

第三部分：
& l. M; t- k/ D) X" h8 s2 c1 u+ S----------------
8 p: N. @1 b( X- k/ y. E, M锚
锚是指它所要匹配的格式，如图C所示。使用它能方便你查找通用字符的合并。例如，我用vi行编辑器命令:s来代表substitute，这一命令的基本语法是：
. p: x; z- N# U' Q: |! K
: X+ f7 f$ `( g; hs/pattern_to_match/pattern_to_substitute/


Table C: Regular expression anchors
-------------
( l0 h& s, S/ N' O: m操作
* [# A& J# W& i  \, ~  J' F9 S解释
例子
& Y/ L/ }: S: n: q) H4 z. N/ a$ @结果
, u1 ?% D4 t3 \9 O5 j$ q---------------
^
" a; N9 e4 f; f$ Z) gMatch at the beginning of a line
3 {4 O3 F8 u5 ~" U2 \s/^/blah /
7 ~- R6 z3 Y" Q* MInserts “blah “ at the beginning of the line
---------------
$
& n6 g% b& L0 q9 ~Match at the end of a line
s/$/ blah/
Inserts “ blah” at the end of the line
---------------
- Z; b2 ?& m$ ]1 H\<
2 f) \' h$ [  @; s3 H6 h9 P9 lMatch at the beginning of a word
s/\Inserts “blah” at the beginning of the word
6 a  ]" i7 o' d  [. E1 p
6 N9 T( u5 B6 W9 k' P3 megrep “\Matches “blahfield”, etc.
2 B. i, D* ]7 Z3 A------------------
\>
Match at the end of a word
s/\>/blah/
Inserts “blah” at the end of the word

egrep “\>blah” sample.txt
Matches “soupblah”, etc.
---------------
  u4 ^- _2 R$ `2 A0 X# k/ e0 J\b
) `" @+ I% J( @2 ^) ]9 d" X/ |Match at the beginning or end of a word
' r- j5 K4 T2 z. t& I4 b; D( degrep “\bblah” sample.txt
% z9 l3 P( q# @; ?Matches “blahcake” and “countblah”
. M7 e* v0 e+ X- Q7 B) X-----------------
\B
7 s" |* B& d/ L/ r: H! P8 @Match in the middle of a word
egrep “\Bblah” sample.txt
! t9 Y) L! Y: N4 Y0 ZMatches “sublahper”, etc.
; H/ x9 n/ @9 X1 o  J* w
3 x4 z( u' J- u+ p$ M* O/ x间隔

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

  v6 E( z, b$ V# ^5 J- O/ hegrep “(n|m)erd” sample.txt

$ Y0 A4 e$ N5 }5 |5 z间隔功能非常强大，特别是当你寻找文件不同拼写的时候，但你可以在下面的例子得到相同的结果：
! ~* y' y! C9 T/ j$ f/ c
egrep “[nm]erd” sample.txt

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

第四部分：
9 q, q. a" c/ ~* Z0 Q----------------
) J3 s* C# V- m" s& s一些保留字符
0 [6 y+ [+ j4 X2 bRes的最后一个最重要特性是保留字符(也称特定字符)。例如，如果你想要查找“ne*rd”和“ni*rd”的字符，格式匹配语句“n[ei]*rd”与“neeeeerd” 和 “nieieierd”相符合，但并不是你要查找的字符。因为‘*’(星号)是个保留字符，你必须用一个反斜线符号来替代它，即：“n[ei]\*rd”。其它的保留字符包括：

3 E8 I3 Q$ a( I1 r8 c4 z^ (carat)
0 u4 X+ o+ T# V3 o. (period)
[ (left bracket}
$ (dollar sign)
0 H; k7 }* @) s& B; P& V( (left parenthesis)
# B! h5 y, R: w7 e) (right parenthesis)
# z' ^9 s4 j! E5 ~9 ]# f# \| (pipe)
* K5 L8 Q9 E7 ]3 V, U" V- g7 j* z* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
/ s* ]8 x7 V5 e7 C\ backslash
一旦你把以上这些字符包括在你的字符搜索中，毫无疑问Res变得非常的难读。比如说以下的PHP中的eregi搜索引擎代码就很难读了。

" m* z% W/ B) h+ ?eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$",$sendto)

) w' b7 q2 t- R2 T1 Z你可以看到，程序的意图很难把握。但如果你抛开保留字符，你常常会错误地理解代码的意思。

总结
在本文中，我们揭开了正则表达式的神秘面纱，并列出了ERE标准的通用语法。如果你想阅览Open Group组织的规则的完整描述，你可以参见：Regular Expressions，欢迎你在其中的讨论区发表你的问题或观点。
5 I8 F# Z0 y# c& E  _. Z/ b
* o: u( c" T3 p! L+ _( b3 l; m3 A另外一篇文章
----------------------------------------
7 I+ o2 \3 f5 F( X! I# T正则表达式和Java编程语言
/ I  u  ?6 t: J  V4 C-----------------------------------------
9 S9 g3 e; f: ~1 I3 s. ]- H' X类和方法

; p1 a" ]! P! P& A下面的类根据正则表达式指定的模式，与字符序列进行匹配。

7 M0 J& H) X1 e7 ]4 _Pattern类

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

, f% J! y& n/ D% t用字符串形式指定的正则表达式，必须先编译成Pattern类的 实例。生成的模式用于创建Matcher对象，它根据正则表达式与任 意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。
. X& v9 y& k4 _) i9 s5 ^
$ n8 K! e! \3 O5 z用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输 入进行匹配。pattern 方法可返回编译这个模式所用的正则表达 式。

7 G  @7 m3 y0 Q# K1 f1 a0 R/ ?split方法是一种方便的方法，它在与此模式匹配的位置将给 定输入序列切分开。下面的例子演示了：
$ i1 P- S" R  R- n+ M9 l
: T( |& Y, _& i. g. G0 Z7 n' w/*
+ S) P5 P0 f% T* c* 用split对以逗号和/或空格分隔的输入字符串进行切分。
*/
& e8 o  k; C8 Z& H2 {import java.util.regex.*;
- z/ y3 H+ y. d
3 Y' Q+ R: @7 F8 v3 Ppublic class Splitter {
public static void main(String[] args) throws Exception {
' ]5 M5 _& C' n1 o/ E) A: T- P9 o// Create a pattern to match breaks
# _' X4 E+ A. a4 W1 dPattern p = Pattern.compile("[,\\s]+");
// Split input with the pattern
9 S1 R4 C" c/ ^* ]7 N* TString[] result =
) L/ }' F5 D! H2 Q   p.split("one,two, three four , five");
, E8 m3 K- M. i1 S. ]/ Mfor (int i=0; iSystem.out.println(result);
$ E7 ]2 s# m: v}
' _- T  E1 J" Y2 S8 O. Y2 }% T4 w1 Z}

* |3 c% D% k4 N% M+ ]Matcher类

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

& J1 ]3 `7 l6 I9 h+ m3 V8 B通过调用某个模式的matcher方法，从这个模式生成匹配器。 匹配器创建之后，就可以用它来执行三类不同的匹配操作：
6 \2 S3 p# D( I9 b+ S, K" l( h
matches方法试图根据此模式，对整个输入序列进行匹配。
& _0 ^0 S- X5 {5 v$ F% `# vlookingAt方法试图根据此模式，从开始处对输入序列进 行匹配。
find方法将扫描输入序列，寻找下一个与模式匹配的地方。
- q2 H& E5 z! O
) }$ h/ O. t+ @  N- M0 ?% Z这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询 匹配器的状态，可以获得更多的信息
0 T; `7 a0 r6 p
/ l, R" ^  b3 j- W. w" ^这个类还定义了用新字符串替换匹配序列的方法，这些字符串的内容如果需 要的话，可以从匹配结果推算得出。

appendReplacement方法先添加字符串中从当前位置到下一个 匹配位置之间的所有字符，然后添加替换值。appendTail添加的 是字符串中从最后一次匹配的位置之后开始，直到结尾的部分。
; ^, G" U: r  m% _9 O- u3 V6 `
- x1 J8 j: `# }例如，在字符串blahcatblahcatblah中，第一个 appendReplacement添加blahdog。第二个 appendReplacement添加blahdog，然后 appendTail添加blah，就生成了： blahdogblahdogblah。请参见示例 简单的单词替换。
- N8 v6 u9 X9 k, B4 L7 B
CharSequence接口

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

Regex情景范例
. i' P: L; T3 z
以下代码范例演示了java.util.regex软件包在各种常见情形 下的用法：

* y' V6 e6 ]; i  g简单的单词替换

/*
* This code writes "One dog, two dogs in the yard."
* to the standard-output stream:
# K8 E1 E" ~* e% }*/
import java.util.regex.*;

2 T" P# z1 R7 m2 H7 a( Lpublic class Replacement {
) B. }3 g1 O, `+ X8 r6 lpublic static void main(String[] args)
; u( m* a( a5 s( c       throws Exception {
// Create a pattern to match cat
Pattern p = Pattern.compile("cat");
' z0 {- i3 X7 Q( g// Create a matcher with an input string
Matcher m = p.matcher("one cat," +
) ?; ~) Z3 ~. F* e( ~# H     " two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// Loop through and create a new String
// with the replacements
; g0 c+ T6 I/ ?while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// Add the last segment of input to
// the new String
3 m6 R8 F/ G) A% Y4 `3 S' xm.appendTail(sb);
8 E( J! ]7 R* |System.out.println(sb.toString());
}
}

3 s) }9 v! s8 l# o) M: Z电子邮件确认

以下代码是这样一个例子：你可以检查一些字符是不是一个电子邮件地址。 它并不是一个完整的、适用于所有可能情形的电子邮件确认程序，但是可以在 需要时加上它。

/*
1 W5 a& A0 ]3 a5 [; n* Checks for invalid characters
: I/ g, C( F. }( Y& ?; {' Y* in email addresses
+ ~5 Z/ s" U4 B2 ^# ]" y*/
7 I* ~7 }& j# c$ |! P5 L/ Hpublic class EmailValidation {
public static void main(String[] args)
/ x1 M( T1 t# ^0 I0 k           throws Exception {
           
2 k! X4 W. a  \& B+ m* hString 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())
System.err.println("Email addresses don't start" +
         " with dots or @ signs.");
//Checks for email addresses that start with
7 d* a9 u4 g+ |, g( f//www. and prints a message if it does.
; t2 l* o! w$ G0 {7 kp = Pattern.compile("^www\\.");
; h' z1 q5 G' A" {/ R2 s( j" _m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
2 N4 b/ }4 S) W" G% u   " with \"www.\", only web pages do.");
6 R4 a, I) V+ y}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
. Y) x7 t+ q: b. Z# s7 ~- z
1 s4 d2 l- L, q4 ]8 {, Lwhile(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
! A9 B; X* V: p& K* }8 oresult = m.find();
6 z* U, J+ [7 v  Q}
2 a/ Y( l  m) S4 h
. b. S* f  r+ S/ ~' c5 X' N- |// Add the last segment of input to the new String
, N2 s. P+ T2 X5 f- r5 bm.appendTail(sb);
. |: r9 R& @5 P! D
. r, m5 }5 R$ A5 y  B5 H0 I$ hinput = sb.toString();
2 R& N! D( h  P! Q
4 s6 i5 v8 G4 Q2 P; ]% Uif (deletedIllegalChars) {
/ r: n* [8 B8 Z" XSystem.out.println("It contained incorrect characters" +
! y, V8 g" h. L* [       " , such as spaces or commas.");
9 V5 y( m* A1 R( I- N. x}
5 O& X& q* Y4 V$ a}
2 v; q# {: Y, z7 W; f* |5 P}

- U3 Y4 Q: F2 W$ G# w4 X' ]从文件中删除控制字符

8 D/ V* y) X0 J6 o' ^# }. y9 K. d6 H9 _/* This class removes control characters from a named
5 Y1 {2 K9 F1 D$ u/ k( i9 d# W0 w* file.
* |* L% I( G( {! |& V1 o) b, p*/
import java.util.regex.*;
import java.io.*;
2 Z) b7 u! b8 }) `! F2 H
6 ^8 m- `5 \* L/ ?" p- Npublic class Control {
public static void main(String[] args)
2 l8 G; Z: ~& ]           throws Exception {
           
//Create a file object with the file name
//in the argument:
File fin = new File("fileName1");
; o9 w2 S  \4 C6 p- `File fout = new File("fileName2");
+ g  P8 k) t$ r* ?8 H//Open and input and output stream
FileInputStream fis =
' u9 f, U1 R9 H       new FileInputStream(fin);
FileOutputStream fos =
       new FileOutputStream(fout);
9 n" {2 ^5 v, t0 G% Q0 `
BufferedReader in = new BufferedReader(
. N" a, r6 S# @2 @     new InputStreamReader(fis));
; h1 T, F& Z$ U1 f, FBufferedWriter out = new BufferedWriter(
  b/ c1 i6 v$ Q& m8 I, A# G     new OutputStreamWriter(fos));

0 }$ F, _+ o3 j6 x  J3 i// The pattern matches control characters
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
6 l; E$ _4 n% f+ R% ]String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//Replaces control characters with an empty
//string.
3 q* @' K4 I! v, hString result = m.replaceAll("");
: z' A; G( e! y0 V( X/ L8 a5 Pout.write(result);
  U1 }! a: b+ S9 I. j: [) P) }out.newLine();
1 e3 }) L# j; z8 f}
in.close();
out.close();
}
: o8 ^2 T: n+ w5 k}

文件查找

/*
' l; Q2 D4 @" L* h4 T* Prints out the comments found in a .java file.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
1 @9 p; F6 X& @* X  m5 d2 Limport java.nio.channels.*;

public class CharBufferExample {
public static void main(String[] args) throws Exception {
// Create a pattern to match comments
Pattern p =
4 ~: a! |' r/ J7 x: z# f: i( fPattern.compile("//.*$", Pattern.MULTILINE);
5 P! e* W8 K9 r& Z% L7 W5 t
// Get a Channel for the source file
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
. @, a. g- @" Y1 ^, pFileChannel fc = fis.getChannel();

// Get a CharBuffer from the source file
" B9 ^8 W  }1 G& X4 o# k2 WByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
; x  i8 I8 U, XCharset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
8 `7 S, y; w" H& M$ p% w# lCharBuffer cb = cd.decode(bb);

, \  d5 M- @! j9 q0 u// Run some matches
1 G7 `* V' Y4 p* B- o6 C, KMatcher m = p.matcher(cb);
# t9 ~" K5 l8 o6 y; C0 O9 fwhile (m.find())
3 W8 L  A3 t; ]* ASystem.out.println("Found comment: "+m.group());
}
}
' P; U1 _" J& b4 y
结论
3 C% ^! x5 S3 ?# N' \' C/ `现在Java编程语言中的模式匹配和许多其他编程语言一样灵活了。可以在应 用程序中使用正则表达式，确保数据在输入数据库或发送给应用程序其他部分之 前，格式是正确的，正则表达式还可以用于各种各样的管理性工作。简而言之， 在Java编程中，可以在任何需要模式匹配的地方使用正则表达式。

JDK1.4之正規表示式
( M9 q5 \7 b% C5 O+ a" z/ u' w1 x) mwritten by william chen(06/19/2002)

% W$ P: j! s: f- x0 U: l+ o--------------------------------------------------------------------------------
9 X* G# O6 K+ \5 ~4 w
什麼是正規表示式呢(Reqular Expressions)
' P2 c% f- O- D' U9 R+ ?9 ^- @& L# f
就是針對檔案、字串，透過一種很特別的表示式來作search與replace
6 `1 h/ {) F2 q; w8 z) Y: R2 j
' D, a# L' w: E& I, E因為在unix上有很多系統設定都是存放在文字檔中，因此網管或程式設計常常需要作搜尋與取代
: Q0 X! m1 W! {3 c5 V
所以發展出一種特殊的命令叫做正規表示式
. H* h5 q! Q9 A7 y; v* k, m
我們可以很簡單的用 "s/
2 `" ?* z& ^/ u因此jdk1.4提供了一組正規表示式的package供大家使用
9 n8 Y3 O! R! b; s% P! k2 B
若是jdk1.4以下的可以到http://jakarta.apache.org/oro取得相關功能的package
6 r/ T& p! T& h3 d7 N
剛剛列出的一串符號" s/
! G* A( u. h! y3 A/ J3 f適用於j2sdk1.4的正規語法
/ x2 O* V7 S- h
$ a) h$ a6 l- g. N"." 代表任何字元

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

"+" 代表一個或以個以上的字元
5 h$ ^' X: \) e: c, R) z"*" 代表零個或是零個以上的字元

正規式 原字串 符合之字串
5 t" r+ D4 ?. e! J: k3 A; u+ ab ab
* abc abc
  o7 G% S! G% a1 z/ y6 p* z
4 }0 h( D, K2 @6 h"( )"群組

( D; {8 @7 o/ [! Z: f$ h正規式 原字串 符合之字串
+ @4 q! n/ m( A' ^, C" J( \0 H" d; B9 W(ab)* aabab abab
" q) B) N* q7 {* T$ F+ Q  I; V
4 `* E* d; |" k0 u' Q) k字元類

' v) _. h5 P0 ^' C/ r9 i正規式 原字串 符合之字串
! P* Q# i7 a' j4 g* y2 s( Q[a-dA-D0-9]* abczA0 abcA0
0 m/ I- g8 l+ |. ]! R& T  A[^a-d]* abe0 e0
[a-d]* abcdefgh abab


: L4 ?# u* A8 b/ c0 h7 N簡式

\d 等於 [0-9] 數字
\D 等於 [^0-9] 非數字
\s 等於 [ \t\n\x0B\f\r] 空白字元
, K( l  `7 W0 s0 K\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 數字或是英文字
\W 等於 [^a-zA-Z_0-9] 非數字與英文字

3 I3 `5 o& d9 W: r! L# U* T" f2 u( C每一行的開頭或結尾

: N0 {/ ~. l* w( ~8 \# V* C^ 表示每行的開頭
5 Q$ G! r- G) M! ]2 L) X' ]; [$ 表示每行的結尾
& |8 T# S6 F- B# R( f
9 m" ]) L! ?7 l--------------------------------------------------------------------------------
" Z( {6 ?! X4 |; O/ ~/ @6 l0 E
2 E1 x  O6 W- L* `% E! {2 k正規表示式 java.util.regex 相關的類別
& V+ u* a9 V% h0 C" ~. `
. ^- z' S' N: TPattern—正規表示式的類別
! f6 w* @8 B% @* V4 }  Q+ b, @, ^Matcher—經過正規化的結果
PatternSyntaxExpression—Exception thrown while attempting to compile a regular expression
; f( F& N' w" j" L# G
範例1: 將字串中所有符合"<"的字元取代成"lt;"

& @+ D3 p) g. d3 y2 ^3 Gimport java.io.*;
import java.util.regex.*;
! w: s' j9 |$ a/**
  h- ~0 F, i' q6 r: |" }2 G* 將字串中所有符合"<"的字元取代成"lt;"
*/
public static void replace01(){
6 i9 j( u0 |7 `  c- T4 Z  A// BufferedReader lets us read line-by-line
) O7 `2 o0 S* T: }2 ]- A0 z1 [8 A9 n. J1 ~Reader r = new InputStreamReader( System.in );
: Y! k7 c" r* N& Y; eBufferedReader br = new BufferedReader( r );
% R& @/ }8 }9 O% YPattern pattern = Pattern.compile( "<" ); // 搜尋某字串所有符合'<'的字元
; T6 h( V3 O* {; p( ]5 _try{
while (true) {
! `3 j* q% w9 T  wString line = br.readLine();
3 m; ]2 f5 I/ N3 P- N/ V8 @// Null line means input is exhausted
! K4 Q% l$ W, ^2 [if (line==null)
$ @* i2 T& }' r+ [2 E, Lbreak;
Matcher a = pattern.matcher(line);
while(a.find()){
- w% w: ?% w, i% OSystem.out.println("搜尋到的字元是" + a.group());
: F) X# L! }9 N; r3 Y}
System.out.println(a.replaceAll("lt;"));// 將所有符合字元取代成lt;
}
}catch(Exception ex){ex.printStackTrace();};
5 u- M  B' k; t6 r% _}
2 }/ q4 d: s1 h5 s, `/ _! N
範例2:
5 Q+ _  I% D1 g4 O
5 X& K9 U5 |& ]" D( m4 }8 X& Yimport java.io.*;
import java.util.regex.*;
- I/ c9 Y" r& c# f  v/**
* 類似StringTokenizer的功能
* 將字串以","分隔然後比對哪個token最長
7 t" k8 i# s) k5 [*/
public static void search01(){
// BufferedReader lets us read line-by-line
0 E$ D- V0 @2 X7 g& o) z0 `Reader r = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( r );
Pattern pattern = Pattern.compile( ",\\s*" );// 搜尋某字串所有","的字元
3 q- F$ f! w  y1 u3 [$ ztry{
while (true) {
String line = br.readLine();
String words[] = pattern.split(line);
" k2 M, F6 N6 p// Null line means input is exhausted
if (line==null)
break;
// -1 means we haven't found a word yet
int longest=-1;
int longestLength=0;
  e: _& q% ?; C! P; x) \for (int i=0; iSystem.out.println("分段:" + words );
if (words.length() > longestLength) {
/ [, e1 G* g2 e! xlongest = i;
longestLength = words.length();
}
8 V! `% y( H! P% ^: |* V}
) r$ T2 [# ~3 |& r! c: U' gSystem.out.println( "長度最長為:" + words[longest] );
0 [# q  ^. b& a6 \* @/ m1 v$ B}
1 j. ]7 ]& M4 P; p7 }}catch(Exception ex){ex.printStackTrace();};
/ N  V) G5 ?6 _}

. l) p- P5 d4 v& X* Z--------------------------------------------------------------------------------
" B* G) W) f$ Q# l5 t3 K
其他的正規語法

' H3 r% G) {0 r, }/^\s* # 忽略每行開始的空白字元
. d8 F2 h" ^0 C. x8 I7 m" M! K(M(s|r|rs)\.) # 符合 Ms., Mrs., and Mr. (titles)

一叶

一头雾水