正则表达式简化模式匹配的代码精品资料.doc

《正则表达式简化模式匹配的代码精品资料.doc》由会员分享，可在线阅读，更多相关《正则表达式简化模式匹配的代码精品资料.doc（54页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、java正则表达式; regular expression日期：2005-7-11 15:58:39 人气：0 大 中 小Java 101 正则表达式简化模式匹配的代码 探索在文本处理场合下涉及模式匹配中正则表达式的优雅之处。 概要文本处理经常涉及的根据一个pattern的匹配。尽管java的character和assorted 的String类提供了low-level的pattern-matching支持，这种支持一般带来了复杂的代码。为了帮助你书写简单的pattern-matching代码，java提供了regular expression。在介绍给你术语和java.util.regex包

2、之后，Jeff Friesen explores 了许多那个包的Pattern类支持的正则表达式结构。然后他examines 了Pattern的方法和附加的java.util.regex 类。作为结束，他提供了一个正则表达式的实践应用。 为察看术语列表，提示与警告，新的homework，上个月homework的回答，这篇文章的相关材料，请访问study guide. (6,000 words; February 7, 2003) By Jeff Friesen ，Translated By humx文本处理经常的要求依据特定pattern匹配的代码。它能让文本检索，email header验证

3、，从普通文本的自定义文本的创建（例如，用Dear Mr. Smith 替代 Dear Customer），等等成为可能。Java通过character和assorted string类支持pattern matching。由于low-level的支持一般带来了复杂的pattern-matching代码，java同时提供了regular expression来简代码。Regular expressions经常让新手迷惑。然而, 这篇文章驱散了大部分混淆。在介绍了regular expression术语，java.util.regex 包中的类, 和一个regular expression con

4、structs的示例程序之后, 我explore了许多Pattern类支持的regular expression constructs。我也examine了组成Pattern 和java.util.regex 包中其它类的方法。一个practical 的正则表达式的应用程序结束了我的讨论。 Note Regular expressions的漫长历史开始于计算机科学理论领域自动控制原理和formal 语言理论。它的历史延续到Unix和其它的操作系统，在那里正则表达式被经常用作在Unix和Unix-like的工具中：像awk（一个由其创作者，Aho, Weinberger, and Kernigh

5、an，命名，能够进行文本分析处理的编程语言）, emacs (一个开发工具)，和grep (一个在一个或多个文件中匹配正则表达式，为了全局地正则表达式打印的工具。 什么是正则表达式? A regular expression，也被known as regex or regexp，是一个描述了一个字符串集合的pattern(template)。这个pattern决定了什么样的字符串属于这个集合，它由文本字符和元字符（metacharacters，由有特殊的而不是字符含义的字符）组成。为了识别匹配的检索文本的过程字符串满足一个正则表达式称作模式匹配（pattern matching）。Javas

6、java.util.regex 包通过Pattern，Matcher类和PatternSyntaxException异常支持pattern matching： Pattern 对象，被known as patterns，是编译的正则表达式。 Matcher 对象，或者matchers，在，实现了java.lang.CharSequence接口并作为文本source的字符序列中定位解释matchers的引擎。 PatternSyntaxException 对象描述非法的regex patterns。Listing 1 介绍这些类： Listing 1. RegexDemo.java / Rege

7、xDemo.javaimport java.util.regex.*;class RegexDemo public static void main (String args) if (args.length != 2) System.err.println (java RegexDemo regex text);return;Pattern p;try p = Ppile (args 0);catch (PatternSyntaxException e) System.err.println (Regex syntax error: + e.getMessage (); System.err

8、.println (Error description: + e.getDescription (); System.err.println (Error index: + e.getIndex (); System.err.println (Erroneous pattern: + e.getPattern (); return;String s = cvtLineTerminators (args 1);Matcher m = p.matcher (s);System.out.println (Regex = + args 0);System.out.println (Text = + s

9、);System.out.println ();while (m.find () System.out.println (Found + m.group (); System.out.println (starting at index + m.start () + and ending at index + m.end (); System.out.println (); / Convert n and r character sequences to their single character / equivalents static String cvtLineTerminators

10、(String s) StringBuffer sb = new StringBuffer (80);int oldindex = 0, newindex;while (newindex = s.indexOf (n, oldindex) != -1) sb.append (s.substring (oldindex, newindex); oldindex = newindex + 2; sb.append (n);sb.append (s.substring (oldindex);s = sb.toString ();sb = new StringBuffer (80);oldindex

11、= 0;while (newindex = s.indexOf (r, oldindex) != -1) sb.append (s.substring (oldindex, newindex); oldindex = newindex + 2; sb.append (r);sb.append (s.substring (oldindex);return sb.toString (); RegexDemos public static void main(String args) 方法validates 两个命令行参数：一个指出正则表达式，另外一个指出文本。在创建一个pattern之后，这个方法

12、转换所有的文本参数，new-line and carriage-return line-terminator 字符序列为它们的实际meanings 。例如，一个new-line字符序列(由反斜杠后跟n表示)转换成一个new-line字符（用数字表示为10）。在输出了regex和被转换的命令行文本参数之后，main(String args) 方法从pattern创建了一个matcher，它随后查找了所有的matches 。对于每一个match，它所出现的字符和信息的位置被输出。为了完成模式匹配，RegexDemo 调用了java.util.regex包中类的不同的方法。不要使你自己现在就理解这些

13、方法；我们将在后边的文章探讨它们。更重要的是，编译 Listing 1: 你需要RegexDemo.class来探索Patterns regex 结构。探索Patterns regex 构造Patterns SDK 文档提供了一部分正则表达式结构的文档。除非你是一个avid正则表达式使用者，一个最初的那段文档的阅读会让你迷惑。什么是quantifiers，greedy之间的不同是什么, reluctant, 和 possessive quantifiers? 什么是 character classes， boundary matchers， back references, 和 embedde

14、d flag expressions? 为了回答这些和其它的问题，我们探索了许多Patter认可的regex constructs或 regex pattern 种类。我们从最简单的regex construct 开始：literal strings。Caution 不要认为Pattern和Perl5的正则表达式结构是一样的。尽管他们有很多相同点，他们也有许多，它们支持的metacharacters结构的不同点。 (更多信息，察看在你的平台上的你的SDK Pattern类的文档。) Literal strings 当你在字处理软件的检索对话框输入一个你指定一个literal string 的时

15、候，你就指定了一个regex expression construct 。执行以下的RegexDemo 命令行来察看一下这个regex construct 的动作： java RegexDemo apple applet上边的这个命令行确定了apple 作为一个包含了字符a, p, p, l, and e（依次）的字符regex construct。 这个命令行同时也确定了applet 作为pattern-matching的文本。执行命令行以后，看到以下输出： Regex = appleText = appletFound applestarting at index 0 and ending

16、 at index 5输出的regex 和text 命令行，预示着在applet中一个applet的成功的匹配，并表示了匹配的开始和结束的索引：分别为0和5。开始索引指出了一个pattern match出现的第一个文本的开始位置，结束索引指明了这个match后的第一个text的位置。换句话说，匹配的text的范围包含在开始索引和去掉结束索引之间（不包含结束索引）。Metacharacters 尽管string regex constructs 是有用的，更强大的regex contsruct联合了文本字符和元字符。例如，在a.b，这个句点metacharacter (.) 代表在a个b之间出现

17、的任何字符。 为了察看元字符的动作， 执行以下命令行： java RegexDemo .ox The quick brown fox jumps over the lazy ox.以上命令指出.ox 作为regex ，和The quick brown fox jumps over the lazy ox.作为文本源text。RegexDemo 检索text来匹配以任意字符开始以ox结束的match，并产生如下输出： Regex = .oxText = The quick brown fox jumps over the lazy ox.Found foxstarting at index 16

18、 and ending at index 19Foundoxstarting at index 39 and ending at index 42这个输出展示了两个matches:fox和ox。. metacharacter 在第一个match中匹配f ，在第二个match中匹配空格。假如我们用前述的metacharacter 替换.ox会怎么样呢？也就是，我们指定java RegexDemo . The quick brown fox jumps over the lazy ox.会有什么样的输出，因为period metacharacter 匹配任何字符， RegexDemo 在命令行输出

19、每一个匹配字符，包括结尾的period字符。 Tip 为了指定.或者任何的元字符作为在一个regex construct 作为literal character，引用转换meta状态到literal status用以下两种方法之一： 在元字符之前放置反斜杠。 将元字符放在Q和E之间（例如：Q.E）。在每种情形下，不要忘记在string literal（例如：String regex = .;）中出现时（像 . or Q.E）的双倍的反斜杠。不要在当它在命令行参数中出现的时候用双倍的反斜杠。 Character classes 有时我们限定产生的matches到一个特定的字符集和。例如，我们可以

20、检索元音a, e, i, o, and u ，任何一个元音字符的出现都以为着一个match。A character类， 通过在方括号之间的一个字符集和指定的regex construct ，帮我们完成这个任务。Pattern 支持以下的character classes： 简单字符: 支持被依次放置的字符串并仅匹配这些字符。例如：abc 匹配字符a, b, and c。以下的命令行提供了另外一个示例： java RegexDemo csw cavejava RegexDemo csw cave csw中c匹配在cave中的c。没有其它的匹配存在。 否定: 以 metacharacter 元字符

21、开始且仅匹配没有在class中出现的字符。例如：abc匹配所有除了a, b, 和c以外的字符，以下的命令行提供了另外一个示例： java RegexDemo csw cavejava RegexDemo csw cave 匹配在cave中遇到的a, v, 和e。没有其它的匹配存在。 范围: 包含在元字符（-）左侧的字符开始，元字符（-）右侧字符结束的所有字符。仅匹配在范围内的字符。例如： a-z 匹配所有的小写字母。以下的命令行提供了另外一个示例： java RegexDemo a-c clownjava RegexDemo a-c clown 匹配在clown中的c。没有其它的匹配存在。 T

22、ip 通过将它们放置在一起来在一个range character class内联合多个范围。例如：a-zA-Z 匹配所有的大写和小写字母。 联合: 由多个嵌套的character classes组成，匹配属于联合结果的所有字符。例如：a-dm-p 匹配字符a到d和m到p。 characters a through d and m through p。以下的命令行提供了另外一个示例：java RegexDemo abc-e abcdefjava RegexDemo abc-e abcdef 匹配它们在abcdef中的副本 a, b, c, d, and e。没有其它的匹配存在。 交集: 由所有嵌

23、套的class的共同部分组成，且仅匹配字符的共同部分。例如：a-z&d-f 匹配字符d, e, 和 f。以下的命令行提供了另外一个示例：java RegexDemo aeiouy&y partyjava RegexDemo aeiouy&y party 匹配在party中的y。没有其它的匹配存在。 差集: 由除了那些在否定嵌套character class中的字符外所有保留的字符组成。例如：a-z&m-p 匹配 字符a到l和q到z。以下的命令行提供了另外一个示例： java RegexDemo a-f&a-c&e abcdefgjava RegexDemo a-f&a-c&e abcdefg

24、匹配在abcdefg中的 d 和f。没有其它的匹配存在。预定义的character classes一些在regexes 中出现足够次数的character classes 提供了shortcuts。Pattern用预定义的character class提供了这样的shortcuts，如Table 1所示。使用预定义的character classes来简化你的regexes和最小化regex语法错误。Table 1. 预定义的character classes Predefined character class Description d A 数字。 相当于0-9。D A 非数字。相当于0-

25、9。s A whitespace character。相当于 tnx0Bfr。S A 非空格字符。相当于s。 w A 一个字符。相当于a-zA-Z_0-9。W A 非字符，相当于w。随后的命令行示例使用了w预定义character class来identify 命令行中的所有word characters。 java RegexDemo w aZ.8 _上边的命令行产生了以下的输出，它展示了句点和space characters 不被考虑为word character： Regex = wText = aZ.8 _Found astarting at index 0 and ending at

26、 index 1Found Zstarting at index 1 and ending at index 2Found 8starting at index 3 and ending at index 4Found _starting at index 5 and ending at index 6Note Pattern的SDK文档引用句点元字符作为匹配除了line terminator，一个或者两个标志一行结束的预定义的标志之外的任何字符，除非 dotall mode (随后讨论)有效。Pattern 识别以下line terminators： The 回车符 (r) The 回行符

27、(n) The 回车符紧跟回行符 (rn) The 回行字符 (u0085) The 行分割字符 (u2028) The 段落分割字符 (u2029)捕获组 Pattern支持在pattern匹配的过程中，一个regex construct 调用capturing group 来保存为了以后recall 的match的字符；此结构是由圆括号包围的字符序列。在捕获的group中的所有字符在匹配的过程中被作为一个单独的单元。例如，(Java) capturing group 结合了字符 J, a, v, 和a为一个单独单元。Capturing group依据在text中Java的出现来匹配Java

28、 pattern。每一个match用下一个匹配的Java字符替代了前一个match保存的Java字符。 Capturing groups 在其它capturing groups内被嵌套。例如：在(Java( language)，( language) 在(Java)内嵌套。每一个嵌套或非嵌套的capturing group有它自己的数字，数字从1开始，Capturing 数字从左边至右。在这个例子中，(Java( language)是capturing group 1，( language)是capturing group 2。在(a)(b)，(a)是捕获组1，(b)是捕获组2。每一个capt

29、uring group随后通过a back reference来recall保存的match。指定跟随在一个反斜杠后的数字来指示一个capturing group，back reference来 recalls 一个capturing group捕获的文本字符。一个back reference 的出现导致了一个matcher 使用the back reference的 capturing group number来recall捕获组保存的match ，然后使用匹配的字符进行进一步的匹配操作。随后的示例示范了为了检查语法错误进行的text 搜索的用法：java RegexDemo (Java(

30、language)2) The Java language language这个例子使用(Java( language)2) regex为了检查语法错误，来检索字符串The Java language language，那里Java直接地在两个连续出现的language之前。Regex 指定了两个capturing groups： number 1 is (Java( language)2)， 它匹配Java language language，number 2 is ( language), 它匹配由language跟随的space characer。2 back reference rec

31、alls number 2s 保存的match，它允许matcher检索空格后跟随language的第二次出现，which 直接地跟随space character and language的第一次出现。随后的输出显示了RegexDemos matcher 找到了什么： Regex = (Java( language)2)Text = The Java language languageFound Java language languagestarting at index 4 and ending at index 26量词Quantifiers大概是理解起来最让人迷惑的regex 结构。

32、一部分混淆来自于尽力的理解18个量词逻辑（六个基本逻辑被组织为三个主要逻辑）。其它的一个混淆来自于费尽的0长度匹配的理解。一旦你理解了这个概念和18 categories， 大部分(假如不是全部)混淆将消失。 Note 简要地, 着一部分主要讨论18 个quantifier categories 和zero-length 匹配的概念。为了更详尽的讨论和更多示例，请学习The Java Tutoria 的Quantifiers部分。一个quantifier 是一个隐式或显示的为一个pattern绑定一个数量值的正则表达式结构。这个数字值解决定了匹配一个pattern的次数。Pattern的六个基

33、本的quantifiers匹配一个pattern一次或者根本不匹配，0次或者多次，一次或者多次，一个精确的数字次数，至少x次和 至少x次但不超过y次。六个基本的quantifier categories 在每一个三个主要的类别：greedy， reluctant和 possessive中复制。Greedy quantifiers 尝试找到最长的匹配。与之对照，reluctant quantifiers 尝试找到最短的匹配。Possessive quantifiers 也尝试找到最长的匹配。然而，他们和greedy quantifies在工作方式上不同。尽管greedy 和possessive

34、quantifiers 迫使一个matcher 在进行第一次匹配之前读取整个的text，greedy quantifiers 常常导致为了找到一个match进行多次尝试，然而possessive quantifiers 让一个matcher 仅尝试一个match一次。 随后的示例描述了六种基本的quantifiers 在greedy category类别下，单个fundamental quantifier 在每一个 reluctant 和 possessive categories类别下的行为。这些示例也描述了0匹配的概念： 1. java RegexDemo a? abaa: 使用一个gre

35、edy quantifier 来在abaa中匹配a 一次或者根本不匹配。以下是输出结果： Regex = a?Text = abaaFound astarting at index 0 and ending at index 1Found starting at index 1 and ending at index 1Found astarting at index 2 and ending at index 3Found astarting at index 3 and ending at index 4Found starting at index 4 and ending at ind

36、ex 4这个输出展示了五次匹配。尽管第一、三和四次匹配的出现展示了三次匹配中位置并不奇怪，第一、第五次的匹配大概有点奇怪。这个匹配好像指出a匹配b和文本的结束。然而，不是这种情况。a?并不查找b和文本结尾。相反， 它查找a的出现或者缺失。当a? 查找a失败的时候，它以零长度的匹配返回那个事实(a缺失)，在零长度那里起始和结束位置的索引相同。Zero-length matches 发生在空文本, 最后一个文本字符之后，或者任何量个字符之间。2. java RegexDemo a* abaa: 使用一个greedy quantifier在abaa 中匹配a零次或多次。以下是输出结果：Regex =

37、 a*Text = abaaFound astarting at index 0 and ending at index 1Found starting at index 1 and ending at index 1Found aastarting at index 2 and ending at index 4Found starting at index 4 and ending at index 4输出展示了四次匹配。像使用 a?，a* 产生了zero-length 匹配。第三个匹配，a* 匹配了aa, 很有趣。不像 a?，a* 匹配一个或者多个连续的a。3. java RegexDe

38、mo a+ abaa: 使用一个greedy quantifier在abaa 中匹配a一次或多次。以下是输出结果： Regex = a+Text = abaaFound astarting at index 0 and ending at index 1Found aastarting at index 2 and ending at index 4输出展示了两个匹配 。不像 a? 和 a*，a+ 没有匹配a的却失。因而，没有零长度匹配产生。像 a*，a+匹配了连续的a。 4. java RegexDemo a2 aababbaaaab: 使用greedy quantifier 来匹配中的每一

39、个 aababbaaaab中的 aa序列。以下是输出结果： Regex = a2Text = aababbaaaabFound aastarting at index 0 and ending at index 2Found aastarting at index 6 and ending at index 8Found aastarting at index 8 and ending at index 105. java RegexDemo a2, aababbaaaab: 使用了greedy quantifier 来匹配在ababbaaaab中两个或更多的匹配，以下是输出结果：Regex

40、= a2,Text = aababbaaaabFound aastarting at index 0 and ending at index 2Found aaaastarting at index 6 and ending at index 106. java RegexDemo a1,3 aababbaaaab: 使用greedy quantifier 来匹配在aababbaaaab中出现的a、aa或者aaa。以下是输出结果： Regex = a1,3Text = aababbaaaabFound aastarting at index 0 and ending at index 2Fou

41、nd astarting at index 3 and ending at index 4Found aaastarting at index 6 and ending at index 9Found astarting at index 9 and ending at index 107. java RegexDemo a+? abaa: 使用一个reluctant quantifier 在abaa中一次或多次匹配a。以下是输出结果：Regex = a+?Text = abaaFound astarting at index 0 and ending at index 1Found asta

42、rting at index 2 and ending at index 3Found astarting at index 3 and ending at index 4不像在第三个例中的greedy变量，reluctant 示例产生了三个单独的匹配，因为reluctant quantifier尽力的查找最短的匹配。 8. java RegexDemo .*+end This is the end: 使用了possessive quantifier 来匹配在this is the end中的以end结尾的任意字符0次或者多次。以下是输出结果：Regex = .*+endText = This

43、 is the end由于这个possessive quantifier consume了整个文本，没有留下任何东西来匹配end，它没有产生匹配。相比之下，在java RegexDemo .*end This is the end 的greedy quantifier，因为它每次backing off一个字符直到最右端的end匹配，产生了一个匹配。(这个quantifier与greedy的不同就在后者的匹配过程中一旦匹配的字符，在随后的匹配中就不再使用。因此.*这部分正则表达式就匹配了全部的字符串，就没有字符可以与end匹配了。)Boundary matchers我们有时想在一行的开始、在单词

44、的边界、文本的结束等等匹配pattern。使用 boundary matcher，一个指定了匹配边界的正则表达式结构，完成这个任务。Table 2 表示了Pattern的边界匹配支持。 Table 2. Boundary matchers Boundary Matcher Description 一行的开始 $ 一行的结束 b 单词的边界 B 非单词边界 A 文本的开始 G 前一个匹配的结束 Z The end of the text (but for the final line terminator, if any) z 文本结束 下边的命令行示例使用了 边界匹配元字符 ensure 由零

45、个或者多个字符跟随的行开始。 java RegexDemo Thew* Therefore 指出了前三个字符必须匹配pattern后的T、h和e字符。可跟随任意数量的字符。以上的命令行产生以下输出： Regex = Thew*Text = ThereforeFound Thereforestarting at index 0 and ending at index 9把命令行改为java RegexDemo Thew* Therefore。发生了什么事?因为在therefore前的一个空格，没有匹配被发现。 Embedded flag expressionsMatcher假设了确定的却省值，例如大小写敏感的匹配。一个程序可以使用an embedded flag