Java 正则表达式学习总结和一些小例子

转 http://www.jb51.net/article/31251.htm

字符串处理是许多程序中非常重要的一部分,它们可以用于文本显示,数据表示,查找键和很多目的.在Unix下,用户可以使用正则表达式的强健功能实现这些 目的

从Java1.4起,Java核心API就引入了java.util.regex程序包,它是一种有价值的基础工具,可以用于很多类型的文本处理, 如匹配,搜索,提取和分析结构化内容. 

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。它包括两个类：Pattern和Matcher. 
Pattern是一个正则表达式经编译后的表现模式。 在java中,通过适当命名的Pattern类可以容易确定String是否匹配某种模式.模式可以象匹配某个特定的String那样简单,也可以很复 杂,需要采用分组和字符类,如空白,数字,字母或控制符.因为Java字符串基于统一字符编码(Unicode),正则表达式也适用于国际化的应用程序. 

Pattern类的方法简述 
方法说明static Pettern compile(String regex,int flag)编译模式,参数regex表示输入的正则表达式,flag表示模式类型(Pattern.CASE_INSENSITIVE 表示不区分大小写)Matcher match(CharSequence input)获取匹配器,input时输入的待处理的字符串static boolean matches(String regex, CharSequence input)快速的匹配调用,直接根据输入的模式regex匹配inputString[] split(CharSequence input,int limit)分隔字符串input,limit参数可以限制分隔的次数

Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。首先一个Pattern实例订制了一个所用语法与 PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

Matcher类的方法简述
方法说明boolean matches()对整个输入字符串进行模式匹配.boolean lookingAt()从输入字符串的开始处进行模式匹配boolean find(int start)从start处开始匹配模式int groupCount()返回匹配后的分组数目String replaceAll(String replacement)用给定的replacement全部替代匹配的部分String repalceFirst(String replacement)用给定的replacement替代第一次匹配的部分 Matcher appendReplacement(StringBuffer sb,String replacement)根据模式用replacement替换相应内容,并将匹配的结果添加到sb当前位置之后StringBuffer appendTail(StringBuffer sb)将输入序列中匹配之后的末尾字串添加到sb当前位置之后.正则表达式中常见通配符: 

对于单字符串比较而言,使用正则表达式没有什么优势.Regex的真正强大之处在于体现在包括字符类和量词(*,+,?)的更复杂的模式上. 
字符类包括: 

复制代码代码如下:

\d 数字 
\D 非数字 
\w 单字字符(0-9,A-Z,a-z) 
\W 非单字字符 
\s 空白(空格符,换行符,回车符,制表符) 
\S 非空白 
[] 由方括号内的一个字符列表创建的自定义字符类 
. 匹配任何单个字符 
下面的字符将用于控制将一个子模式应用到匹配次数的过程. 
? 重复前面的子模式0次到一次 
* 重复前面的子模式0次或多次 
+ 重复前面的子模式一次到多次 

以下是实例部分: 

实例一: 
正则式是最简单的能准确匹配一个给定String的模式,模式与要匹配的文本是等价的.静态的Pattern.matches方法用于比较一个String是否匹配一个给定模式.例程如下: 

复制代码代码如下:

String data="java"; 
boolean result=Pattern.matches("java",data); 

实例二: 

复制代码代码如下:

String[] dataArr = { "moon", "mon", "moon", "mono" }; 
for (String str : dataArr) { 
String patternStr="m(o+)n"; 
boolean result = Pattern.matches(patternStr, str); 
if (result) { 
System.out.println("字符串"+str+"匹配模式"+patternStr+"成功"); 
} 
else{ 
System.out.println("字符串"+str+"匹配模式"+patternStr+"失败"); 
} 
} 

模式是”m(o+)n”,它表示mn中间的o可以重复一次或多次,因此moon,mon,mooon能匹配成功,而mono在n后多了一个o,和模式匹配不上. 

注: 
+表示一次或多次;?表示0次或一次;*表示0次或多次. 
实例三: 

复制代码代码如下:

String[] dataArr = { "ban", "ben", "bin", "bon" ,"bun","byn","baen"}; 
for (String str : dataArr) { 
String patternStr="b[aeiou]n"; 
boolean result = Pattern.matches(patternStr, str); 
if (result) { 
System.out.println("字符串"+str+"匹配模式"+patternStr+"成功"); 
} 
else{ 
System.out.println("字符串"+str+"匹配模式"+patternStr+"失败"); 
} 
} 

注:方括号中只允许的单个字符,模式“b[aeiou]n”指定,只有以b开头,n结尾,中间是a,e,i,o,u中任意一个的才能匹配上,所以数组的前五个可以匹配,后两个元素无法匹配. 
方括号[]表示只有其中指定的字符才能匹配. 
实例四: 

复制代码代码如下:

String[] dataArr = { "been", "bean", "boon", "buin" ,"bynn"}; 
for (String str : dataArr) { 
String patternStr="b(ee|ea|oo)n"; 
boolean result = Pattern.matches(patternStr, str); 
if (result) { 
System.out.println("字符串"+str+"匹配模式"+patternStr+"成功"); 
} 
else{ 
System.out.println("字符串"+str+"匹配模式"+patternStr+"失败"); 
} 
} 

如果需要匹配多个字符,那么[]就不能用上了,这里我们可以用()加上|来代替,()表示一组,|表示或的关系,模式b(ee|ea|oo)n就能匹配been,bean,boon等. 
因此前三个能匹配上,而后两个不能. 
实例五: 

复制代码代码如下:

String[] dataArr = { "1", "10", "101", "1010" ,"100+"}; 
for (String str : dataArr) { 
String patternStr="\d+"; 
boolean result = Pattern.matches(patternStr, str); 
if (result) { 
System.out.println("字符串"+str+"匹配模式"+patternStr+"成功"); 
} 
else{ 
System.out.println("字符串"+str+"匹配模式"+patternStr+"失败"); 
} 
} 

注:从前面可以知道,\d表示的是数字,而+表示一次或多次,所以模式\d+就表示一位或多位数字. 
因此前四个能匹配上,最后一个因为+号是非数字字符而匹配不上. 
[/code] 
实例六: 

复制代码代码如下:

String[] dataArr = { "a100", "b20", "c30", "df10000" ,"gh0t"}; 
for (String str : dataArr) { 
String patternStr="\w+\d+"; 
boolean result = Pattern.matches(patternStr, str); 
if (result) { 
System.out.println("字符串"+str+"匹配模式"+patternStr+"成功"); 
} 
else{ 
System.out.println("字符串"+str+"匹配模式"+patternStr+"失败"); 
} 
} 

模式\w+\d+表示的是以多个单字字符开头,多个数字结尾的字符串,因此前四个能匹配上,最后一个因为数字后还含有单字字符而不能匹配. 
实例七: 

复制代码代码如下:

String str="薪水,职位 姓名;年龄 性别"; 
String[] dataArr =str.split("[,\s;]"); 
for (String strTmp : dataArr) { 
System.out.println(strTmp); 
} 

String类的split函数支持正则表达式,上例中模式能匹配”,”,单个空格,”;”中的一个,split函数能把它们中任意一个当作分隔符,将一个字符串劈分成字符串数组. 
实例八: 

复制代码代码如下:

String str="2007年12月11日"; 
Pattern p = Pattern.compile("[年月日]"); 
String[] dataArr =p.split(str); 
for (String strTmp : dataArr) { 
System.out.println(strTmp); 
} 

Pattern是一个正则表达式经编译后的表现模式 ,它的split方法能有效劈分字符串. 
注意其和String.split()使用上的不同. 
实例九: 

复制代码代码如下:

String str="10元 1000人民币 10000元 100000RMB"; 
str=str.replaceAll("(\d+)(元|人民币|RMB)", "￥"); 
System.out.println(str); 

上例中,模式“(\d+)(元|人民币|RMB)”按括号分成了两组,第一组\d+匹配单个或多个数字,第二组匹配元,人民币,RMB中的任意一个,替换部分表示第一个组匹配的部分不变,其余组替换成￥. 
替换后的str为￥10 ￥1000 ￥10000 ￥100000

更正:System.out.println(str.replaceAll("(\\d+)(元|人民币|RMB)", "$1￥"));
(\\d+)(元|人民币|RMB)： 分两个组，第一组(\\d+) 表示匹配0-9 的数字 
                                  第二组(元|人民币|RMB) 表示要匹配的数字后的参数 


"$1￥": { 

1、$ 表示在匹配的后面 
2、1 表示引用第一个组 
3、￥ 表示在引用的第一组后面添加￥ 

}
 

实例十: 

复制代码代码如下:

Pattern p = Pattern.compile("m(o+)n",Pattern.CASE_INSENSITIVE); 
// 用Pattern类的matcher()方法生成一个Matcher对象 
Matcher m = p.matcher("moon mooon Mon mooooon Mooon"); 
StringBuffer sb = new StringBuffer(); 
// 使用find()方法查找第一个匹配的对象 
boolean result = m.find(); 
// 使用循环找出模式匹配的内容替换之,再将内容加到sb里 
while (result) { 
m.appendReplacement(sb, "moon"); 
result = m.find(); 
} 
// 最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里； 
m.appendTail(sb); 
System.out.println("替换后内容是" + sb.toString()); 

实例十一: 
除了用+表示一次或多次,*表示0次或多次,?表示0次或一次外,还可以用{}来指定精确指定出现的次数,X{2,5}表示X最少出现2次,最多出现5次;X{2,}表示X最少出现2次,多则不限;X{5}表示X只精确的出现5次. 
例程: 

复制代码代码如下:

String[] dataArr = { "google", "gooogle", "gooooogle", "goooooogle","ggle"}; 
for (String str : dataArr) { 
String patternStr = "g(o{2,5})gle"; 
boolean result = Pattern.matches(patternStr, str); 
if (result) { 
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功"); 
} else { 
System.out.println("字符串" + str + "匹配模式" + patternStr + "失败"); 
} 
} 

实例十二: 
-表示从..到…,如[a-e]等同于[abcde] 

复制代码代码如下:

String[] dataArr = { "Tan", "Tbn", "Tcn", "Ton","Twn"}; 
for (String str : dataArr) { 
String regex = "T[a-c]n"; 
boolean result = Pattern.matches(regex, str); 
if (result) { 
System.out.println("字符串" + str + "匹配模式" + regex + "成功"); 
} else { 
System.out.println("字符串" + str + "匹配模式" + regex + "失败"); 
} 
} 

实例十三:不区分大小写匹配. 
正则表达式默认都是区分大小写的,使用了Pattern.CASE_INSENSITIVE则不对大小写进行区分. 

复制代码代码如下:

String patternStr="ab"; 
Pattern pattern=Pattern.compile(patternStr, Pattern.CASE_INSENSITIVE); 
String[] dataArr = { "ab", "Ab", "AB"}; 
for (String str : dataArr) { 
Matcher matcher=pattern.matcher(str); 
if(matcher.find()){ 
System.out.println("字符串" + str + "匹配模式" + patternStr + "成功"); 
} 
} 

实例十四:使用正则表达式劈分字符串. 

复制代码代码如下:

注意这里要把复杂的模式写在前面,否则简单模式会先匹配上. 
String input="职务=GM 薪水=50000 , 姓名=职业经理人 ; 性别=男 年龄=45 "; 
String patternStr="(\s*,\s*)|(\s*;\s*)|(\s+)"; 
Pattern pattern=Pattern.compile(patternStr); 
String[] dataArr=pattern.split(input); 
for (String str : dataArr) { 
System.out.println(str); 
} 

实例十五:解析正则表达式中的文字,对应第一个小括号括起来的group1. 

复制代码代码如下:

String regex="<(\w+)>(\w+)</>"; 
Pattern pattern=Pattern.compile(regex); 
String input="<name>Bill</name><salary>50000</salary><title>GM</title>"; 
Matcher matcher=pattern.matcher(input); 
while(matcher.find()){ 
System.out.println(matcher.group(2)); 
} 

实例十六:将单词数字混合的字符串的单词部分大写. 

复制代码代码如下:

String regex="([a-zA-Z]+[0-9]+)"; 
Pattern pattern=Pattern.compile(regex); 
String input="age45 salary500000 50000 title"; 
Matcher matcher=pattern.matcher(input); 
StringBuffer sb=new StringBuffer(); 
while(matcher.find()){ 
String replacement=matcher.group(1).toUpperCase(); 
matcher.appendReplacement(sb, replacement); 
} 
matcher.appendTail(sb); 
System.out.println("替换完的字串为"+sb.toString());

http://deerchao.net/tutorials/regex/regex.htm 

正则表达式30分钟入门教程

转http://www.java3z.com/cwbwebhome/article/article8/81251.html

捕获分组的注意事项： 只要使用了括号，就存在捕获分组 捕获分组按照开括号出现的从左到右的顺序编号，遇到括号嵌套的情况也是如此 如果捕获分组之后存在量词，则匹配结果中，捕获分组保存的是子表达式最后一次匹配的字符串例子：import java.util.regex.Matcher;import java.util.regex.Pattern;public class GeneralSix { public static void main(String[] args) {   String email = "[e-mail]";  String regex = "((\\w+)@([\\d\\.\\w]+))";  Pattern p = Pattern.compile(regex);  Matcher m = p.matcher(email);   if(m.find()){    System.out.println("匹配结果:\t" + m.group(0));    System.out.println("分组1:\t" + m.group(1));    System.out.println("分组2:\t" + m.group(2));    System.out.println("分组3:\t" + m.group(3));    } }  }

运行结果：
匹配结果: [e-mail]
分组1: [e-mail]
分组2: abacdemasterhappy
分组3: 163.com

String regex = "((\\w+)@([\\d\\.\\w]+))";
只是在正则表达式的两端添加了一个( )，此时出现括号嵌套的情况。
依照括号从左到右的顺序，发现，第一个括号对应整个正则表达式，第二个对应用户名正则表达式，第三个括号用于匹配主机名的正则表达式。
再看一个：

import java.util.regex.*;public class GeneralSeven { public static void main(String[] args) {   String email = "[e-mail]";  String regex = "(\\w)+@([\\d\\.\\w])+";  Pattern p = Pattern.compile(regex);  Matcher m = p.matcher(email);  if(m.find()){   System.out.println("匹配结果:\t" + m.group(0));   System.out.println("分组1:\t" + m.group(1));   System.out.println("分组2:\t" + m.group(2));   //System.out.println("分组3:\t" + m.group(3));   } } }

运行结果：
匹配结果: [e-mail]
分组1: y
分组2: m

将量词作用整个捕获分组。匹配完成之后，捕获分组所保存的就是最后一次它所匹配的文本。
[e-mail]
相当于匹配用户名的最后一个字符。
捕获分组的事项讲解到此！

不捕获文本的括号
如果正则表达式很复杂，或者需要处理的文本很长，捕获分组会降低效率
作用：仅仅用来对表达式分组，而不把分组捕获的文本存入结果
形式：
(?:...)
注意：不捕获文本的括号，并不是所有语言都有提供，为了增加可读性，并不推荐使用“不捕获文本的括号”。
例子：

import java.util.regex.*;public class GeneralEight { public static void main(String[] args) {   String email = "[e-mail]";  String regex = "(?:abacdemasterhappy|admin)@(163.com)";  Pattern p = Pattern.compile(regex);  Matcher m = p.matcher(email);  if(m.find()){   System.out.println("匹配结果:\t" + m.group(0));   System.out.println("分组1:\t" + m.group(1));  } } }

运行结果：
匹配结果: [e-mail]
分组1: 163.com

括号的用途：反向引用
作用：在表达式的某一部分，动态重复之前子表达式所匹配的文本
形式：\1
例子：

public class GeneralNine {  public static void main(String[] args) {   String[] strs = new String[] { "< h1>good,good< /h1>", "< h1>bad< /h2>"};  String regex = "< \\w+>[^<]+< /\\w+>";  for (String string : strs) {   if(regexMatch(string,regex)){     System.out.println(string +"能够匹配正则:" + regex);   }else{     System.out.println(string +"不能够匹配正则:" + regex);   } }}  private static boolean regexMatch(String s, String regex) {   return s.matches(regex);  } }

运行结果：
<h1>good,good</h1>能够匹配正则:<\w+>[^<]+</\w+>
<h1>bad</h2>能够匹配正则:<\w+>[^<]+</\w+>