(八) 正则表达式

正则表达式(regular expression)用于指定字符串的模式
(1)字符类(character class)是一个括在括号中的可选字符集，例如，[Jj]、[0-9]、[A-Za-z]或[^0-9]。这里"-"是表示范围，而"^"表示补集(除了指定字符之外的所有字符)
(2)预定的字符类，例如\d(数字)和\p{Sc}(Unicode货币符号)
(3)大部分字符都可以与它们自身匹配
(4)"."符合可以匹配任何字符
(5)使用"\"作为转义字符，例如，"\."匹配句号而"\\"匹配反斜线
(6)"^"和"$"分别匹配一行的开头和结尾
(7)如果X和Y是正则表达式，那么XY表示"任何X匹配后面跟随着Y的匹配"，X|Y表示"任何X或Y的匹配"
(8)可以将量词运用到表达式X : X+(1个或多个)、X*(0或多个)和X?(0个或1个)
(9)一般情况下，量词要匹配能够使整个匹配成功的最大可能的重复次数。可以修改这种行为使用后缀?(最小匹配次数)或使用+(即使整个匹配失败，也要匹配最大的重复次数)
(10)使用群组来定义子表达式，其中群组使用括号()号括起来，例如([+-]?)([0-9]+)

正则表达式的最简单用法就是测试某个特定的字符串是否与它匹配。
e.g.使用Java来编写测试，首先用表示正则表达式的字符串创建一个Pattern对象，然后从这个模式中获得一个Matcher，并调用它的matcher方法
    Pattern pattern = Pattern.compile(patternString)
    Matcher matcher = pattern.matcher(input)
    if(matcher.matcher()){...}
这个匹配器的输入可以是任何实现了CharSequence接口的类的对象，例如String、StringBuilder和CharBuffer
e.g.在编译这个模式时，可以设置一个或多个标志
    Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
支持的六个标示
(1)CASE_INSENSITIVE : 匹配字符时忽略字母的大小写。默认情况下，只考虑USASCII字符。
(2)UNICODE_CASE : 当于CASE_INSENSITIVE组合时，用Unicode字符大小写来匹配。
(3)MULTILINE : ^和$匹配行的开头和结尾，而不是整个输入的开头和结尾。
(4)UNIX_LINES : 在多行模式中匹配^和$时，只有'\n'被识别成行终止符。
(5)DOTALL : 当使用这个标志时，"."符合匹配所有字符，包括行终止符。
(6)CANON_EQ : 考虑Unicode字符规范的等价性，例如，u后面跟随''(分音符号)匹配u上面两点。

如果正则表达式包含群组，那么Matcher对象可以揭示群组的边界 : int start(int groupIndex) 和 int end(int groupIndex) 将产生指定群组的开始索引和结束之后的索引。
可以直接抽取匹配的字符串 : String group(int groupIndex)
群组0是整个输入，而用于第一个实际群组的群组索引是1。调用groupCount可以获得全部群组的数量。
嵌套群组是按照前括号排序的，例如((1?[0-9]):(0-5)[0-9])[ap]m和11:59am
匹配器会报告的群组:
群组索引    开始  结束  字符串
      0             0       7       11:59am
      1             0       5       11:59
      2             0       2       11
      3             3       5       59

 

						正则表达式语法
        	语法                                          解释
字符        
    c                                               字符c
    \unnn,\xnn,\0n,\0nnn            			具有给定十六进制或十进制的码元
    \t,\n,\r,\f,\a,\e                          	控制符:制表符、换行符、回车符、换行符、警告符、逃逸符
    \Cc                                         与字符c相关的控制符
字符类
    [C1C2...]                                   任何由C1、C2...表示的字符，其中C1可以是多个字符，字符范围(c1-c2)和字符类
    [^...]                                      字符集的补集
    [...&&...]                                 	两个字符集的交集
预定义字符类
    \d                                          一个数字[0-9]
    \D                                          一个非数字[^0-9]
    \s                                          一个空白字符[\t\n\r\f\x0B]
    \S                                          一个非空白字符
    \w                                          一个词语字符[a-zA-Z]
    \W                                          一个非词语字符
    \p[name]                                	一个命名字符类
    \P[name]                                	一个非命名字符类
边界匹配符
    ^ $                               			输入的开头和结尾(或者在多行模式下行的开头和结尾)
    \b                       					一个词语边界
    \B                           				一个非词语边界
    \A                                   		输入的开头
    \z                                  		输入的结尾
    \Z                                   		除了行终止符之外的输入结尾
    \G                                   		前一个匹配的结尾

量词
    X?                                          可选的X   
    X*                                          X，0或多次
    X+                                         	X，1或多次
    X{n} X{n,} X{n,m}                  			X为n次，至少n次，在n到m次之间
量词后缀
    ?                                        	勉强匹配
    +                                           占有匹配
集合操作
    XY                                          任何X中的字符串，后面跟随任何Y中的字符串
    X|Y                                         任何X中或Y中的字符串
群组
    (X)                                         捕获将X作为群组匹配的字符串
    \n                                          第n个群组的匹配
转义
    \c                                          字符c(必须是不在字母表中的字符)
    \Q...\E                                   	逐字的引用
    (?...)                               		特殊结构

 

 

DEMO

 

import java.security.acl.Group;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class RegexTest {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("Enter pattern:");
		String patternString = in.nextLine();
		
		Pattern pattern = null;
		try{
			pattern = Pattern.compile(patternString);
		}catch(PatternSyntaxException e){
			e.printStackTrace();
			System.out.println("error");
			System.exit(1);
		}
		
		while(true){
			System.out.println("Enter string to match:");
			String input = in.nextLine();
			if(input==null || "".equals(input)){
				return;
			}
			
			Matcher matcher = pattern.matcher(input);
			if(matcher.matches()){
				System.out.println("Match");
				int groupCount = matcher.groupCount();
				if(groupCount>0){
					for(int i=0;i<input.length();i++){
						for(int j=1;j<=groupCount;j++){
							if(i == matcher.start(j)){
								System.out.print("(");
							}
						}
						System.out.print(input.charAt(i));
						for(int j=1;j<=groupCount;j++){
							if(i+1==matcher.end(j)){
								System.out.print(")");
							}
						}
					}
					System.out.println();
				}
			}else{
				System.out.println("No Match");
			}
		}
		
	}
}