Android 正则表达式 Pattern 和 Matcher



正则表达式是一个非常强大的工具，它对于字符串的处理提供非常强大的功能。今天这篇文章只是简要的简绍下正则表达式的语法，以及如何在java中应用它。

那么什么是正则表达式呢？在百度百科中是这么描述的：在计算机科学中，是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。在很多文本编辑器或其他工具里，正则表达式通常被用来检索和/或替换那些符合某个模式的文本内容。许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。

为了认识什么是正则表达式，先举一个简单的例子：

[java] view plain copy print ?

1. "aa".matches(".*");  

"aa".matches(".*");

查阅API文档，我们找到了这个方法 ：public boolean matches(String regularExpression);其中传入的参数就是正则表达式。

一，简单是认识 ".", "\d", "\D", "\s", "\S", "\w", "\W"

上面这些在正则表达式中被称为：Prefined character classes（已定义好的字符类）。

"."Any character (may or may not match line
terminators)

用于匹配任意一个字符。

"\d"A digit:[0-9]

用于匹配数字，它和[0-9]是等价的

"\D"A non-digit:[^0-9]

用于匹配非数字，和[^0-9]是等价的

"\s"A whitespace character:[ \t\n\x0B\f\r]

用于匹配空白字符，其中包括：空格，\t,\n,\x0B,\f,\r，它的用法和：[ \t\n\x0B\f\r]等价

“\S"A non-whitespace character:[^\s]

用于匹配非空白字符。

"\w"A word character:[a-zA-Z_0-9]

用于匹配word字符，包括a-z的小写字符，A-Z的大写字符，下划线和数字。

"\W"A non-word character:[^\w]

用于匹配非word字符。

二，简答认识正则表达式中的”集合“，及"[","]"的使用。

[abc]a,b or c.

可以用数学中集合中的概念”或“来描述。及可以描述成：a或b或c。

[^abc]Any character except a,b,c

这个类似于集合中求补集的概念，也可以理解成”非“。及除了a，b，c外的任意字符。

[a-zA-Z]和[a-z[A-Z]]

两者都是“a-z或A-Z”的意思。前者是平行关系，或者是并集关系。

[a-z&&[def]]intersection

就是取交集的意思。

三，边界匹配，"^", "$", "\b", "\B" , "\A", "\G", "\Z", "\z"

"^"The beginning of a line

匹配字符串的开头。如，"abc".matches("^a.*");返回true。

"$"The end of a line

匹配字符串的结尾。如，"abc".matches("abc$");返回true。

"\b"A word boundary

匹配单词边界。如，"hello world".matches("hello\\b\\swordl");返回true。

"\B"A non-word boundary

匹配非单词边界。

"\A"The beginning of the input

匹配输入的开头。

"\G"The end of the previos match

"\Z"The
end of the input but for the final terminator, if any

"\z"The end of the input.

三，限定次数。又分三种：Greedy quantifiers,Reluctant quantifiers和Possessive quantifiers

1，Greedy quantifiers。

其实三种模式的用法基本上相同，只是在匹配的策略上会有所不同，所以结果有时会有不同。

X?X,once or not at all

X出现一次或一次也没有出现。

X*X,zero or more times

X没有出现或出现任意次。

X+X,once or more times

X出现一次或一次以上

X{n}X,exactly n times

X刚好出现n次

X{n,}X,at least n times

X至少出现n次

X{n,m}X,atleast n times bu no more than m times

X出现次数在n和m范围之间

2，Reluctant quantifiers

X??,X*?,X+?,X{n}?,X{n,?}?,X{n,m}?各自的解释对应于Greedy quantifiers 中的解释。

3，Possessve quantifiers

X?+,X*+,X++,X{n}+,X{n,?}+,X{n,m}+各自的解释对应于Greedy
quantifiers 中的解释。

那么他们三个有什么不同之处呢？先看一下下面的例子：

1，Greedy quantifiers:

[java] view plain copy print ?

1. Pattern p = Pattern.compile("\\w+\\d{2}");  
2.         Matcher m = p.matcher("aa22bb22");  
3.         if(m.find()){  
4.             System.out.println(m.group());  
5.         }  

Pattern p = Pattern.compile("\\w+\\d{2}");
		Matcher m = p.matcher("aa22bb22");
		if(m.find()){
			System.out.println(m.group());
		}

此时输出结果为：aa22bb22；

2，Reluctant quantifiers:

[java] view plain copy print ?

1. Pattern p = Pattern.compile("\\w+?\\d{2}");  
2.         Matcher m = p.matcher("aa22bb22");  
3.         if(m.find()){  
4.             System.out.println(m.group());  
5.         }  

Pattern p = Pattern.compile("\\w+?\\d{2}");
		Matcher m = p.matcher("aa22bb22");
		if(m.find()){
			System.out.println(m.group());
		}

此时输出结果为:aa22；

3，Possessive quantifiers;

Pattern p = Pattern.compile("\\w++\\d{2}");

[java] view plain copy print ?

1. Matcher m = p.matcher("aa22bb22");  
2. if(m.find()){  
3.     System.out.println(m.group());  
4. }  

		Matcher m = p.matcher("aa22bb22");
		if(m.find()){
			System.out.println(m.group());
		}

此时输出结果为空，就是说没有得到匹配的结果。

那么从上面个的例子我们容易看出它们直接的区别还是很大的，从名字上来看，Greedy：贪婪的。意思就是想在在匹配的结果中找打尽可能长的字符串。Reluctant：不情愿的。意思就是从匹配的结果中找到尽可能短的字符串。Possessive：占有欲强的。就是一次匹配正则表达式中最长的长度来匹配，如果次长度匹配不了就不再进行匹配。

四，Pattern 和 Matcher

这两个类是java中用于正则表示的最基础的两个类，上面的例子中也用到了这两个类，其中提供了许多实用的方法。这就需要我们在实用的时候去查阅API文旦了。

当然，限于篇幅和本文的初衷，只写了其中最基础的一些用法，在Pattern的文档中还有其他常用的一些匹配，需要我们在实用的时候去查阅文档了。

最后在提醒一点，在java中凡是要用到斜杠"\"的地方一定要用双斜杠"\\"来代替，因为单斜杠会和其他字符组合成为转义字符。

原文：http://blog.csdn.net/chenshaoyang0011/article/details/7217449