字符串（4）：正则表达式（中）

超、凢脫俗 2023-07-10 11:19 19阅读 0赞

### 四、Pattern和Matcher ###

**（1）Pattern和Matcher**

一般来说，比起功能有限的String类，我们更愿意构造功能强大的正则表达式对象。只需导入java.util.regex包，然后用static Pattern.compile()方法来编译你的正则表达式即可。它会根据你的String类型的正则表达式生成一个Pattern对象。接下来，把你想要检索的字符串传入Pattern对象的matcher()方法。matcher()方法会生成一个Matcher对象，它有很多功能可用（可以参考java.util.regext.Matcher的JDK文档）。例如，它的replaceAll()方法能将所有匹配的部分都替换成你传入的参数。

作为第一个示例，下面的类可以用来测试正则表达式，看看它们能否匹配一个输入字符串。第一个控制台参数是将要用来搜索匹配的输入字符串，后面的一个或多个参数都是正则表达式，它们将被用来在输出的第一个字符串中查找匹配。在Unix/Linux上，命令行中的正则表达式必须用引号括起来。这个程序在测试正则表达式时很有用，特别是当你想验证它们是否具备你所期待的匹配功能的时候。

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class TestRegularExpression {
    	public static void main(String[] args) {
    		args = new String[] { "abcabcabcdefabc", "abc+", "(abc)+", "(abc){2,}" };
    		if (args.length < 2) {
    			System.out.println("Usage:\njava TestRegularExpression characterSequence regularExpression+");
    			System.exit(0);
    		}
    		System.out.println("Input:\"" + args[0] + "\"");
    		for (String arg : args) {
    			System.out.println("Regular expression:\"" + arg + "\"");
    			Pattern p = Pattern.compile(arg);
    			Matcher m = p.matcher(args[0]);
    			while (m.find()) {
    				System.out.println("Math \"" + m.group() + "\" at positions " + m.start() + "-" + (m.end() - 1));
    			}
    		}
    	}
    }

Pattern对象表示编译后的正则表达式。从这个例子中可以看到，我们使用已编译的Pattern对象的matcher()方法，加上一个输入字符串，从而共同构造了一个Mathcer对象。同时，Pattern类还提供了static方法：

static boolean matchers(String regex, CharSequence input);

该方法用以检查regex是否匹配整个CharSequence类型的input参数。编译后的Pattern对象还提供了split()方法，它从匹配了regex的地方分割输入字符串，返回分割后的子字符串String数组。

通过调用Pattern.matcher()方法，并传入一个字符串参数，我们得到了一个Matcher对象。使用Matcher上的方法，我们将能够判断各种不同类型的匹配是否成功：

boolean matchers();
    boolean lookingAt();
    boolean find();
    boolean find(int start);

其中的matcher()方法用来判断整个输入字符串是否匹配正则表达式模式，而lookingAt()则用来判断该字符串（不必是整个字符串）的报告开头部分是否能够匹配模式。

**（2）find()**

Match.find()方法可用来在CharSequece中查找多个匹配。例如：

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Finding {
    	public static void main(String[] args) {
    		Matcher m = Pattern.compile("\\w+").matcher("Evening is full of the linnet's wings");
    		while (m.find())
    			System.out.print(m.group() + " ");
    		System.out.println();
    		int i = 0;
    		while (m.find(i)) {
    			System.out.print(m.group() + " ");
    			i++;
    		}
    	}
    }

模式\\\\w+将字符串划分为单词。find()像迭代器那样向前遍历输入字符串。而第二个find()能够接收一个整数作为参数，该整数表示字符串中字符的位置，并以其作为搜索的起点。从结果中可以看出，后一个版本的find()方法能根据其参数的值，不断重新设定搜索的起始位置。

**（3）组（Groups）**

组是用括号划分的正则表达式，可以根据组的编号来引用某个组。组号为0表示整个表达式，组号1表示被第一对括号括起来的组，以此类推。因此，在这个表达式：A(B(C))D。中有三个组：组0是ABCD，组1是BC，组2是C。

Matcher对象提供了一系列方法，用以获取与组相关的信息：public int groupCount()返回该匹配器的模式中的分组数目，第0组不包括在内。public String group()返回前一次匹配操作（例如find()）的第0组（整个匹配）。public String group(int i)返回前一次匹配操作期间指定的组号，如果匹配成功，但是指定的组没有匹配输入字符串的任何部分，则将返回null。public int start(int group)返回在前一次匹配操作中寻找到的组的起始索引。pubic int end(int group)返回在前一次匹配操作中寻找到的组的最后一个字符索引加一的值。

下面是正则表达式组的例子：

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Groups {
    	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 = Pattern.compile("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$").matcher(POEM);
    		while(m.find()) {
    			for (int i = 0; i <= m.groupCount(); i++) 
    				System.out.print("[" + m.group(i) + "]");
    			System.out.println();
    		}
    	}
    }

可以看到这个正则表达式模式有许多圆括号分组，由任意数目的非空格字符（\\S+）及随后的任意数目的空格字符（\\s+）所组成。目的是捕获每行的最后三个单词，每行最后以$结束。不过，在正常情况下是将$与整个输入序列的末端相匹配。所以我们一定要显式地告知正则表达式注意输入序列中的换行符。这可以由序列开头的模式标记(?m)来完成（模式标记马上就会介绍）。

**（4）start()与end()**

在匹配操作成功之后，start()返回先前匹配的起始位置的索引，而end()返回所匹配的最后字符的索引加一的值。匹配操作失败之后（或先于一个正在进行的匹配操作去尝试）调用start()或end()将会产生IllegalStateException。下面的示例还同时展示了matches和lookingAt()的用法：

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class StartEnd {
    	public static String input=
    			"As long as there is injustice, whenever a\n"
    			+"Targathian baby cries out. wherever a distress\n"
    			+"signal sounds among the stars ... we'll be there.\n"
    			+"This fine ship, and this fine crew ... \n"
    			+"Never give up! Never surrender!";
    	
    	private static class Display {
    		private boolean regexPrinted = false;
    		private String regex;
    		
    		Display(String regex){
    			this.regex = regex;
    		}
    		
    		void display(String message) {
    			if(!regexPrinted) {
    				System.out.println(regex);
    				regexPrinted = true;
    			}
    			System.out.println(message);
    		}
    	}
    	
    	static void examine(String s,String regex) {
    		Display d = new Display(regex);
    		Pattern p = Pattern.compile(regex);
    		Matcher m = p.matcher(s);
    		while(m.find())
    			d.display("find() '" + m.group() + "' start = " + m.start() + " end = " + m.end()); 
    		if(m.lookingAt())
    			d.display("lookingAt() start = " + m.start() + " end = " + m.end()); 
    		if(m.matches())	
    			d.display("matches() start = " + m.start() + " end = " + m.end()); 
    	}
    	
    	public static void main(String[] args) {
    		for (String in : input.split("\n")) {
    			System.out.println("input : " + in);
    			for (String regex : new String[] {"\\w*ere\\w*", "\\w*ever", "T\\w+", "Never.*?!"}) 
    				examine(in, regex);
    		}
    	}
    }

注意，find()可以在输入的任意位置定位正则表达式，而lookingAt()和matches()只有在正则表达式与输入的最开始处就开始匹配时才会成功。matches()只有在整个输入都匹配正则表达式时才会成功，而lookingAt()只要输入的第一部分匹配就会成功。

**（5）Pattern标记**

Pattern类的compile()方法还有另一个版本，它接受一个标记参数，以调整匹配的行为：

Pattern Pattern.compile(String regex,int flags);

其中的flag来自以下Pattern类中的常量：

<table> 
 <tbody> 
  <tr> 
   <td>编译标记</td> 
   <td style="width:603px;">效果</td> 
  </tr> 
  <tr> 
   <td> <p>Pattern.CANON_EQ</p> </td> 
   <td style="width:603px;">&nbsp; &nbsp; 两个字符当且仅当它们的完全规范分解相匹配时，就认为它们是匹配的。例如，如果我们指定这个标记，表达式a\u030A就会匹配字符串？。在默认的情况下，匹配不考虑规范的等价性。</td> 
  </tr> 
  <tr> 
   <td>Pattern.CASE_INSENSITIVE（?i）</td> 
   <td style="width:603px;">&nbsp; &nbsp; 默认情况下，大小写不敏感的匹配假定只有US-ASCII字符集中的字符才能进行。这个标记允许模式匹配不必考虑大小写。通过指定UNICODE_CASE标记及结合此标记，基于Unicode的大小写不敏感的匹配就可以开启了。</td> 
  </tr> 
  <tr> 
   <td>Pattern.COMMENTS（?x）</td> 
   <td style="width:603px;">&nbsp; &nbsp; 这种模式下，空格符将被忽略掉，并且以#开始直到行末的注释也会被忽略掉。通过嵌入的标记表达式也可以开启Unix的行模式。</td> 
  </tr> 
  <tr> 
   <td>Pattern.DOTALL（?s）</td> 
   <td style="width:603px;">&nbsp; &nbsp; 在dotall模式中，表达式“.”匹配所有字符，包括行终结符。默认情况下，“.”表达式不匹配行终结符。</td> 
  </tr> 
  <tr> 
   <td>Pattern.MULTILINE（?m）</td> 
   <td style="width:603px;">&nbsp; &nbsp; 在多行模式下，表达式^和$分别匹配一行的开始和结束。^还匹配输入字符串的开始，而$还匹配输入字符串的结尾。默认情况下，这些表达式仅匹配输入的完整字符串的开始和结束。</td> 
  </tr> 
  <tr> 
   <td>Pattern.UNICODE_CASE（?u）</td> 
   <td style="width:603px;">&nbsp; &nbsp; 当指定这个标记，并且开启CASE_INSENSITIVE时，大小写不敏感的匹配将按照与Unicode标准相一致的方式进行。默认情况下，大小写不敏感的匹配假定只能在US-ASCII字符集中的字符才能进行。</td> 
  </tr> 
  <tr> 
   <td>Pattern.UNIX_LINES（?d）</td> 
   <td style="width:603px;">&nbsp; &nbsp; 在这种模式下，在. 、^和$行为中，只识别行终结符\n。</td> 
  </tr> 
 </tbody> 
</table>

这这些标记中，Pattern.CASE\_INSENSITIVE、Pattern.MULTILINE以及Pattern.COMMENTS（对声明或文档）特别有用。请注意，你可以直接在正则表达式中使用其中的大多数标记，只需要将上表中括号括起来的字符插入到正则表达式中，你希望它起作用的位置即可。

你还可以通过“或”（|）操作符组合多个标记功能：

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Reflags {
    	public static void main(String[] args) {
    		Pattern p = Pattern.compile("^java", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
    		Matcher m = p.matcher(
    				"java has regex\nJava has regex\nJAVA has pretty good regular expressions\nRegular expressions are in Java");
    		while (m.find())
    			System.out.println(m.group());
    	}
    }

在这个例子中，我们创建了一个模式，它将匹配所有以“java”、“Java”和“JAVA”等开头的行，并且是在设置了多行标记的状态下，对每一个行（从字符序列的第一个字符开始，至每一行终结符）都进行匹配。注意，group()方法只返回已匹配的部分。

**未完待续。如果本文对您有很大的帮助，还请点赞关注一下。**