java基础巩固系列（十二）：java正则表达式入门以及Pattern、Matcher类详解

一、正则表达式入门

1、定义：正则表达式使用单个字符串来描述、匹配一系列符合某个语法规则的字符串，由特定的字符组合而成。

2、用途：字符串的查找、匹配、替换、分割

3、实现类：

java.util.regex.Pattern：指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象

java.util.regex.Matcher：通过调用模式的matcher 方法从模式创建匹配器，创建匹配器后，可进行三种操作：

matches 方法尝试将整个输入序列与该模式匹配。
lookingAt 尝试将输入序列从头开始与该模式匹配。
find 方法扫描输入序列以查找与该模式匹配的下一个子序列。

接下来会详细讲解

二、Pattern类与Matcher类的使用

我们看一个简单的例子：

public static void main(String[] args) {
		// 要验证的字符串
	    String str = "程序设计协会";
	    // 正则表达式规则
	    String strRegex = "程序.*";
	    // 编译正则表达式
	    Pattern pattern = Pattern.compile(strRegex);
	    //创建匹配器
	    Matcher matcher = pattern.matcher(str);
	    // 查找字符串中是否有匹配正则表达式的 字符/字符串
	    boolean rs = matcher.matches();
	    System.out.println(rs);
	}

打印结果是：true

1、String[]Pattern.split(CharSequence input)

定义：按照正则表达式对字符串进行分割（这是一个静态方法，可以直接通过类名Pattern直接调用）

例子：

public static void main(String[] args) {
		String[] fakeFileData = { 
			"abc/def/ghi", 
			"jkl/mno/pqr" }; 
		Pattern p = Pattern.compile("/");
		for(String data : fakeFileData) { 
			String[] tokens = p.split(data); 
			for(String token : tokens) { 
				System.out.print(token+" ");
			} 
			System.out.println(); 
		} 
	}

打印结果：

abc def ghi 
jkl mno pqr

2、boolean Pattern.matches(String regex,CharSequence input)

定义：按照正则表达式与字符串进行匹配，返回boolean（这是一个静态方法，直接通过Pattern类可以调用）
例子：

public static void main(String[] args) {
		System.out.println(Pattern.matches("\\d{3}", "123"));
	}

打印结果：true

3、Matcher matcher(CharSequence input)

定义：创建匹配给定输入与此模式的匹配器，返回一个Matcher对象（匹配器）

注意：这不是一个静态方法，需要通过Pattern对象进行调用

4.Matcher.matches()、 Matcher.lookingAt()、 Matcher.find() （非静态方法）

（1）Matcher.matches

对整个字符串进行匹配,只有整个字符串都匹配了才返回true

// 要验证的字符串
	    String str = "程序设计协会";
	    // 正则表达式规则
	    String strRegex = "程序.*";
	    // 编译正则表达式
	    Pattern pattern = Pattern.compile(strRegex);
	    //创建匹配器
	    Matcher matcher = pattern.matcher(str);
	    // 查找字符串中是否有匹配正则表达式的 字符/字符串
	    boolean rs = matcher.matches();
	    System.out.println(rs);

（2）Matcher.lookingAt()

尝试将输入序列从头开始与该模式匹配，只要开头的子字符串匹配成功，则返回true

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("22bb23"); 
m.lookingAt();//返回true,因为\d+匹配到了前面的22 
Matcher m2=p.matcher("aa2223"); 
m2.lookingAt();//返回false,因为\d+不能匹配前面的aa

（3）Matcher.find()

扫描输入序列，在任何位置只要查找到与正则表达式匹配的字符串则返回true

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("22bb23"); 
m.find();//返回true 
Matcher m2=p.matcher("aa2223"); 
m2.find();//返回true 
Matcher m3=p.matcher("aa2223bb"); 
m3.find();//返回true 
Matcher m4=p.matcher("aabb"); 
m4.find();//返回false

5.Mathcer.start()、 Matcher.end()、 Matcher.group() （非静态方法）

当使用4所说的matches(),lookingAt(),find()三个方法执行匹配操作后,就可以利用以上三个方法得到更详细的信息

这里用Matcher.find()方法举例：

使用find()与正则表达式结合循环匹配替换：

public static void main(String[] args) {
		String s = "abc123def456ghi789";
		String sRegex = "\\d+";
		Pattern p = Pattern.compile(sRegex);
		Matcher matcher = p.matcher(s);
		while(matcher.find()){
			int start = matcher.start();
			int end = matcher.end();
			String str = matcher.group();
			System.out.println("开始位置："+start+",结束位置："+end+",查找到的字符串："+str);
			s = s.replace(matcher.group(), "替换后的内容");
		}	
	}

打印结果：

开始位置：3,结束位置：6,查找到的字符串：123
开始位置：9,结束位置：12,查找到的字符串：456
开始位置：15,结束位置：18,查找到的字符串：789

（1）start()方法获取查找到的字符串的开始索引

（2）end()方法获取查找到的字符串的结束索引

（3）group()方法得到查找到的字符串的值

三、正则表达式的语法

1、字符类：

`[abc]`	`a`、`b` 或`c`（简单类）
`[^abc]`	任何字符，除了 `a`、`b` 或`c`（否定）
`[a-zA-Z]`	`a` 到 `z` 或 `A` 到 `Z`，两头的字母包括在内（范围）
`[a-d[m-p]]`	`a` 到 `d` 或 `m` 到 `p`：`[a-dm-p]`（并集）
`[a-z&&[def]]`	`d`、`e` 或`f`（交集）
`[a-z&&[^bc]]`	`a` 到 `z`，除了 `b` 和 `c`：`[ad-z]`（减去）
`[a-z&&[^m-p]]`	`a` 到 `z`，而非 `m` 到 `p`：`[a-lq-z]`（减去）

例子：

"a".matches("[abc]");//true
 "ad".matches("[^abc]");//false
 "A".matches("[a-zA-Z]");//true
 "A".matches("[a-z]|[A-Z]");//true
 "A".matches("[a-z[A-Z]]");//true
 "R".matches("[A-Z&&[RFG]]");//true

2、预定义字符类

`.`	任何字符（与行结束符可能匹配也可能不匹配）
`\d`	数字：`[0-9]`
`\D`	非数字： `[^0-9]`
`\s`	空白字符：`[ \t\n\x0B\f\r]`
`\S`	非空白字符：`[^\s]`
`\w`	单词字符：`[a-zA-Z_0-9]`
`\W`	非单词字符：`[^\w]`

public static void main(String[] args) {
		"a".matches("."); //true
		"1".matches("\\d");//true
		"a".matches("\\D");//true
		" ".matches("\\s");//true
		"a".matches("\\S");//true
		"~".matches("\\w");//false
		"~".matches("\\W");//true
	}

3、边界匹配器

`^`	行的开头
`$`	行的结尾
`\b`	单词边界
`\B`	非单词边界
`\A`	输入的开头
`\G`	上一个匹配的结尾
`\Z`	输入的结尾，仅用于最后的结束符（如果有的话）
`\z`	输入的结尾

public static void main(String[] args) {
		"abcd".matches("^a.*"); //true
		"abcd".matches(".*d$"); //true
		"ab cd".matches(".*\\b.*"); //true
		"abcd".matches("\\A.*"); //true
	}

4、Greedy数量词、Reluctant数量词、Possessive数量词

http://blog.csdn.net/u010800530/article/details/42884039

反斜线字符 ('\') 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式\\ 与单个反斜线匹配，而\{ 与左括号匹配。

在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。