文档介绍：该【正则表达式 】是由【读书百遍】上传分享，文档一共【19】页，该文档可以免费在线阅读，需要了解更多关于【正则表达式 】的内容，可以使用淘豆网的站内搜索功能，选择自己适合的文档，以下文字是截取该文章内的部分文字，如需要获得完整电子版，请下载此文档到您的设备，方便您编辑和打印。正则体现式- -
Tag： 正则体现式                                          
正则体现式
作为本章的结尾，我们来看一看正则体现式(regular expression)。正则体现式是JDK ，但是对sed和awk这样的Unix的原则实用工具，以及Python，Perl之类的语言来讲，它早就已经成为其不可或缺的构成部分了(有人甚至认为，它还是Perl能大获成功的最重要的因素)。单从技术角度来讲，正则体现式只是一种解决字符串的工具(过去Java这个任务是交由String，StringBuffer以及StringTokenizer解决的)，但是它经常和I/O一起使用，因此放到这里来讲也不算太离题吧。[66]
正则体现式是一种功效强大但又非常灵活的文本解决工具。它能让你用编程的方式来描述复杂的文本模式，然后在字符串里把它找出来。一旦你找到了这种模式，你就能随心所欲地解决这些文本了。即使初看起来正则体现式的语法有点让人望而生畏，但它提供了一种精练的动态语言，使我们能用一种通用的方式来解决多种字符串的问题，涉及匹配，选择，编辑以及校验。
创立正则体现式
你能够从比较简朴的东西入手学习正则体现式。要想全方面地掌握如何构建正则体现式，。
字符
B
字符B
\xhh
16进制值0xhh所示的字符
\uhhhh
16进制值0xhhhh所示的Unicode字符
\t
Tab
\n
换行符
\r
回车符
\f
换页符
\e
Escape
正则体现式的强大致现在它能定义字符集(character class)。下面是某些最常见的字符集及其定义的方式，另外尚有某些预定义的字符集：
字符集
.
表达任意一种字符
[abc]
表达字符a，b，c中的任意一种(与a|b|c相似)
[^abc]
除a，b，c之外的任意一种字符(否认)
[a-zA-Z]
从a到z或A到Z当中的任意一种字符(范畴)
[abc[hij]]
a,b,c,h,i,j中的任意一种字符(与a|b|c|h|i|j相似)(并集)
[a-z&&[hij]]
h,i,j中的一种(交集)
\s
空格字符(空格键, tab, 换行, 换页, 回车)
\S
非空格字符([^\s])
\d
一种数字，也就是[0-9]
\D
一种非数字的字符，也就是[^0-9]
\w
一种单词字符(word character)，即[a-zA-Z_0-9]
\W
一种非单词的字符，[^\w]
如果你用过其它语言的正则体现式，那么你一眼就能看出反斜杠的与众不同。在其它语言里，"\\"的意思是"我只是要在正则体现式里插入一种反斜杠。没什么特别的意思。"但是在Java里，"\\"的意思是"我要插入一种正则体现式的反斜杠，因此跟在它背面的那个字符的意思就变了。"举例来说，如果你想表达一种或更多的"单词字符"，那么这个正则体现式就应当是"\\w+"。如果你要插入一种反斜杠，那就得用"\\\\"。但是像换行，跳格之类的还是只用一根反斜杠："\n\t"。
这里只给你讲一种例子；，这样就能很容易地找到多种正则体现式的模式了。
逻辑运算符
XY
X 背面跟着 Y
X|Y
X或Y
(X)
一种"要匹配的组(capturing group)". 后来能够用\i来表达第i个被匹配的组。
边界匹配符
^
一行的开始
$
一行的结尾
\b
一种单词的边界
\B
一种非单词的边界
\G
前一种匹配的结束
举一种具体某些的例子。下面这些正则体现式都是正当的，并且都能匹配"Rudolph"：
Rudolph
[rR]udolph
[rR][aeiou][a-z]ol.*
R.*
数量表达符
"数量表达符(quantifier)"的作用是定义模式应当匹配多少个字符。
Greedy(贪婪的)： 除非另有表达，否则数量表达符都是greedy的。Greedy的体现式会始终匹配下去，直到匹配不下去为止。(如果你发现体现式匹配的成果与预期的不符)，很有可能是由于，你觉得体现式会只匹配前面几个字符，而事实上它是greedy的，因此会始终匹配下去。
Reluctant(勉强的)： 用问号表达，它会匹配最少的字符。也称为lazy, minimal matching, non-greedy, 或ungreedy。
Possessive(占有的)： 现在只有Java支持(其它语言都不支持)。它更加先进，因此你可能还不太会用。用正则体现式匹配字符串的时候会产生诸多中间状态，(普通的匹配引擎会保存这种中间状态，)这样匹配失败的时候就能原路返回了。占有型的体现式不保存这种中间状态，因此也就不会回头重来了。它能避免正则体现式的失控，同时也能提高运行的效率。
Greedy
Reluctant
Possessive
匹配
X?
X??
X?+
匹配一种或零个X
X*
X*?
X*+
匹配零或多个X
X+
X+?
X++
匹配一种或多个X
X{n}
X{n}?
X{n}+
匹配正好n个X
X{n,}
X{n,}?
X{n,}+
匹配最少n个X
X{n,m}
X{n,m}?
X{n,m}+
匹配最少n个，至多m个X
再提示一下，要想让体现式照你的意思去运行，你应当用括号把'X'括起来。比方说：
abc+
似乎这个体现式能匹配一种或若干个'abc'，但是如果你真的用它去匹配'abcabcabc'的话，事实上只会找到三个字符。由于这个体现式的意思是'ab'后边跟着一种或多个'c'。要想匹配一种或多个完整的'abc'，你应当这样：
(abc)+
正则体现式能轻而易举地把你给耍了；这是一种建立在Java之上的新语言。
CharSequence
JDK ，叫CharSequence。它提供了String和StringBuffer这两个类的字符序列的抽象：
interface CharSequence {
charAt(int i);
length();
subSequence(int start, int end);
toString();
}
为了实现这个新的CharSequence接口，String，StringBuffer以及CharBuffer都作了修改。诸多正则体现式的操作都要拿CharSequence作参数。
Pattern和Matcher
先给一种例子。下面这段程序能够测试正则体现式与否匹配字符串。第一种参数是要匹配的字符串，背面是正则体现式。正则体现式能够有多个。在Unix/Linux环境下，命令行下的正则体现式还必须用引号。
当你创立正则体现式时，能够用这个程序来判断它是不是会按照你的规定工作。
//: c12:
// Allows you to easly try out regular expressions.
// {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }
import .*;
public class TestRegularExpression {
public static void main(String[] args) {
if( < 2) {
("Usage:\n" +
"java TestRegularExpression " +
"characterSequence regularExpression+");
(0);
}
("Input: \"" + args[0] + "\"");
for(int i = 1; i < ; i++) {
(
"Regular expression: \"" + args[i] + "\"");
Pattern p = (args[i]);
Matcher m = (args[0]);
while(()) {
("Match \"" + () +
"\" at positions " +
() + "-" + (() - 1));
}
}
}
} ///:~
。Pattern对象表达经编译的正则体现式。静态的compile( )办法负责将表达正则体现式的字符串编译成Pattern对象。正如上述例程所示的，只要给Pattern的matcher( )办法送一种字符串就能获取一种Matcher对象。另外，Pattern尚有一种能快速判断能否在input里面找到regex的(注意，原文有误，漏了办法名)
static boolean matches( regex,  input)
以及能返回String数组的split( )办法，它能用regex把字符串分割开来。
( )办法传一种字符串就能获得Matcher对象了。接下来就能用Matcher的办法来查询匹配的成果了。
boolean matches()
boolean lookingAt()
boolean find()
boolean find(int start)
matches( )的前提是Pattern匹配整个字符串，而lookingAt( )的意思是Pattern匹配字符串的开头。
find( )
( )的功效是发现CharSequence里的，与pattern相匹配的多个字符序列。例如：
//: c12:
import .*;
import .*;
import .*;
public class FindDemo {
private static Test monitor = new Test();
public static void main(String[] args) {
Matcher m = ("\\w+")
.matcher("Evening is full of the linnet's wings");
while(())
(());
int i = 0;
while((i)) {
(() + " ");
i++;
}
(new String[] {
"Evening",
"is",
"full",
"of",
"the",
"linnet",
"s",
"wings",
"Evening vening ening ning ing ng g is is s full " +
"full ull ll l of of f the the he e linnet linnet " +
"innet nnet net et t s s wings wings ings ngs gs s "
});
}
} ///:~
"\\w+"的意思是"一种或多个单词字符"，因此它会将字符串直接分解成单词。find( )像一种迭代器，从头到尾扫描一遍字符串。第二个find( )是带int参数的，正如你所看到的，它会告诉办法从哪里开始找——即从参数位置开始查找。
Groups
Group是指里用括号括起来的，能被背面的体现式调用的正则体现式。Group 0 表达整个体现式，group 1表达第一种被括起来的group，以这类推。因此；
A(B(C))D
里面有三个group：group 0是ABCD， group 1是BC，group 2是C。
你能够用下述Matcher办法来使用group：
public int groupCount( )返回matcher对象中的group的数目。不涉及group0。
public String group( ) 返回上次匹配操作(比方说find( ))的group 0(整个匹配)
public String group(int i)返回上次匹配操作的某个group。如果匹配成功，但是没能找到group，则返回null。
public int start(int group)返回上次匹配所找到的，group的开始位置。
public int end(int group)返回上次匹配所找到的，group的结束位置，最后一种字符的下标加一。
下面我们举某些group的例子：
//: c12:
import .*;
import .*;
public class Groups {
private static Test monitor = new Test();
static public final String poem =
"Twas brillig, and the slithy toves\n" +
"Did gyre and gimble in the wabe.\n" +
"All mimsy were the borogoves,\n" +
"And the mome raths outgrabe.\n\n" +
"Beware the Jabberwock, my son,\n" +
"The jaws that bite, the claws that catch.\n" +
"Beware the Jubjub bird, and shun\n" +
"The frumious Bandersnatch.";
public static void main(String[] args) {
Matcher m =
("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$")
.matcher(poem);
while(()) {
for(int j = 0; j <= (); j++)
("[" + (j) + "]");
();
}
(new String[]{
"[the slithy toves]" +
"[the][slithy toves][slithy][toves]",
"[in the wabe.][in][the wabe.][the][wabe.]",
"[were the borogoves,]" +
"[were][the borogoves,][the][borogoves,]",
"[mome raths outgrabe.]" +
"[mome][raths outgrabe.][raths][outgrabe.]",
"[Jabberwock, my son,]" +
"[Jabberwock,][my son,][my][son,]",
"[claws that catch.]" +
"[claws][that catch.][that][catch.]",
"[bird, and shun][bird,][and shun][and][shun]",
"[The frumious Bandersnatch.][The]" +
"[frumious Bandersnatch.][frumious][Bandersnatch.]"
});
}
} ///:~
这首诗是Through the Looking Glass的，Lewis Carroll的"Jabberwocky"的第一部分。能够看到这个正则体现式里有诸多用括号括起来的group，它是由任意多个持续的非空字符('\S+')和任意多个持续的空格字符('\s+')所构成的，其最后目的是要捕获每行的最后三个单词；'$'表达一行的结尾。但是'$'普通表达整个字符串的结尾，因此这里要明确地告诉正则体现式注意换行符。这一点是由'(?m)'标志完毕的(模式标志会过一会解说)。
start( )和end( )
如果匹配成功，start( )会返回本次匹配的开始位置，end( )会返回本次匹配的结束位置，即最后一种字符的下标加一。如果之前的匹配不成功(或者没匹配)，那么无论是调用start( )还是end( )，都会引发一种IllegalStateException。下面这段程序还演示了matches( )和lookingAt( )：
//: c12:
import .*;
import .*;
public class StartEnd {
private static Test monitor = new Test();
public static void main(String[] args) {
String[] input = new String[] {
"Java has regular expressions in ",
"regular expressions now expressing in Java",
"Java represses oracular expressions"
};
Pattern
p1 = ("re\\w*"),
p2 = ("Java.*");
for(int i = 0; i < ; i++) {
("input " + i + ": " + input[i]);
Matcher
m1 = (input[i]),
m2 = (input[i]);
while(())
("() '" + () +
"' start = "+ () + " end = " + ());
while(())
("() '" + () +
"' start = "+ () + " end = " + ());
if(()) // No reset() necessary
("() start = "
+ () + " end = " + ());
if(())
("() start = "
+ () + " end = " + ());
if(()) // No reset() necessary
("() start = "
+ () + " end = " + ());
if(())
("() start = "
+ () + " end = " + ());
}
(new String[] {
"input 0: Java has regular expressions in ",
"() 'regular' start = 9 end = 16",
"() 'ressions' start = 20 end = 28",
"() 'Java has regular expressions in '" +
" start = 0 end = 35",
"() start = 0 end = 35",
"() start = 0 end = 35",
"input 1: regular expressions now " +
"expressing in Java",
"() 'regular' start = 0 end = 7",
"() 'ressions' start = 11 end = 19",
"() 'ressing' start = 27 end = 34",
"() 'Java' start = 38 end = 42",
"() start = 0 end = 7",
"input 2: Java represses oracular expressions",
"() 'represses' start = 5 end = 14",
"() 'ressions' start = 27 end = 35",
"() 'Java represses oracular expressions' " +
"start = 0 end = 35",
"() start = 0 end = 35",
"() start = 0 end = 35"
});
}
} ///:~
注意，只要字符串里有这个模式，find( )就能把它给找出来，但是lookingAt( )和matches( )，只有在字符串与正则体现式一开始就相匹配的状况下才干返回true。matches( )成功的前提是正则体现式与字符串完全匹配，而lookingAt( )[67]成功的前提是，字符串的开始部分与正则体现式相匹配。
匹配的模式(Pattern flags)
compile( )办法尚有一种版本，它需要一种控制正则体现式的匹配行为的参数：
Pattern (String regex, int flag)
flag的取值范畴以下：