正则表达式及小例子.docx
《正则表达式及小例子.docx》由会员分享，可在线阅读，更多相关《正则表达式及小例子.docx（30页珍藏版）》请在冰豆网上搜索。
正则表达式及小例子
字符串处理是许多程序中非常重要的一部分,它们可以用于文本显示,数据表示,查找键和很多目的.在Unix下,用户可以使用正则表达式的强健功能实现
这些目的,从Java1.4起,Java核心API就引入了java.util.regex程序包,它是一种有价值的基础工具,可以用于很多类型的文本处理,如匹配,搜索,提取
和分析结构化内容.
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。
它包括两个类：
Pattern和Matcher.
Pattern是一个正则表达式经编译后的表现模式。
在java中,通过适当命名的Pattern类可以容易确定String是否匹配某种模式.模式可以象匹配某个特
定的String那样简单,也可以很复杂,需要采用分组和字符类,如空白,数字,字母或控制符.因为Java字符串基于统一字符编码（Unicode）,正则表达式也
适用于国际化的应用程序.
Pattern类的方法简述
方法说明
staticPetterncompile（Stringregex,intflag）编译模式,参数regex表示输入的正则表达式,flag表示模式类型（Pattern.CASE_INSENSITIVE表示
不区分大小写）
Matchermatch（CharSequenceinput）获取匹配器,input时输入的待处理的字符串
staticbooleanmatches（Stringregex,CharSequenceinput）快速的匹配调用,直接根据输入的模式regex匹配input
String[]split（CharSequenceinput,intlimit）分隔字符串input,limit参数可以限制分隔的次数
Matcher一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。
首先一个Pattern实例订制了一个所用语法与
PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。
Matcher类的方法简述
方法说明
booleanmatches（）对整个输入字符串进行模式匹配.
booleanlookingAt（）从输入字符串的开始处进行模式匹配
booleanfind（intstart）从start处开始匹配模式
intgroupCount（）返回匹配后的分组数目
StringreplaceAll（Stringreplacement）用给定的replacement全部替代匹配的部分
StringrepalceFirst（Stringreplacement）用给定的replacement替代第一次匹配的部分
MatcherappendReplacement（StringBuffersb,Stringreplacement）根据模式用replacement替换相应内容,并将匹配的结果添加到sb当前位置之后
StringBufferappendTail（StringBuffersb）将输入序列中匹配之后的末尾字串添加到sb当前位置之后.
正则表达式中常见通配符:
对于单字符串比较而言,使用正则表达式没有什么优势.Regex的真正强大之处在于体现在包括字符类和量词（*,+,?
）的更复杂的模式上.
字符类包括:
\d数字
\D非数字
\w单字字符（0-9,A-Z,a-z）
\W非单字字符
\s空白（空格符,换行符,回车符,制表符）
\S非空白
[]由方括号内的一个字符列表创建的自定义字符类匹配任何单个字符
下面的字符将用于控制将一个子模式应用到匹配次数的过程.
?
重复前面的子模式0次到一次
*重复前面的子模式0次或多次
+重复前面的子模式一次到多次
匹配中文字符的正则表达式：
[\u4e00-\u9fa5]
匹配双字节字符（包括汉字在内）：
[^\x00-\xff]
应用：
计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function（）{returnthis.replace（[^\x00-\xff]/g,"aa"）.length;}
匹配空行的正则表达式：
\n[\s|]*\r
匹配HTML标记的正则表达式：
/<（.*）>.*<\/\1>|<（.*）\/>/
匹配首尾空格的正则表达式：
（^\s*）|（\s*$）
以下是实例部分:
实例一:
正则式是最简单的能准确匹配一个给定String的模式,模式与要匹配的文本是等价的.静态的Pattern.matches方法用于比较一个String是否匹配一个给定模式.例程如下:
Stringdata="java";
booleanresult=Pattern.matches（"java",data）;
输出：
true
实例二:
String[]dataArr={"moon","mon","moon","mono"};
StringpatternStr="m（o+）n";
booleanresult=false;
for（Stringstr:
dataArr）{
result=Pattern.matches（patternStr,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
} else{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"失败"）;
}
}
输出：
字符串moon匹配模式m（o+）n成功
字符串mon匹配模式m（o+）n成功
字符串moon匹配模式m（o+）n成功
字符串mono匹配模式m（o+）n失败
模式是”m（o+）n”,它表示mn中间的o可以重复一次或多次,因此moon,mon,mooon能匹配成功,而mono在n后多了一个o,和模式匹配不上.
注:
+表示一次或多次;?
表示0次或一次;*表示0次或多次.
实例三:
String[]dataArr={"ban","ben","bin","bon","bun","byn","baen"};
StringpatternStr="b[aeiou]n";
booleanresult=false;
for（Stringstr:
dataArr）{
result=Pattern.matches（patternStr,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
}
else{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"失败"）;
}
}
输出：
字符串ban匹配模式b[aeiou]n成功
字符串ben匹配模式b[aeiou]n成功
字符串bin匹配模式b[aeiou]n成功
字符串bon匹配模式b[aeiou]n成功
字符串bun匹配模式b[aeiou]n成功
字符串byn匹配模式b[aeiou]n失败
字符串baen匹配模式b[aeiou]n失败
注:
方括号中只允许的单个字符,模式“b[aeiou]n”指定,只有以b开头,n结尾,中间是a,e,i,o,u中任意一个的才能匹配上,所以数组的前五个可以匹配,后两个元素无法匹配。
方括号[]表示只有其中指定的字符才能匹配.
实例四:
String[]dataArr={"been","bean","boon","buin","bynn"};
StringpatternStr="b（ee|ea|oo）n";
for（Stringstr:
dataArr）{
booleanresult=Pattern.matches（patternStr,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
} else{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"失败"）;
}
}
输出：
字符串been匹配模式b（ee|ea|oo）n成功
字符串bean匹配模式b（ee|ea|oo）n成功
字符串boon匹配模式b（ee|ea|oo）n成功
字符串buin匹配模式b（ee|ea|oo）n失败
字符串bynn匹配模式b（ee|ea|oo）n失败
如果需要匹配多个字符,那么[]就不能用上了,这里我们可以用（）加上|来代替,（）表示一组,|表示或的关系,模式b（ee|ea|oo）n就能匹配been,bean,boon等，因此前三个能匹配上,而后两个不能.
实例五:
String[]dataArr={"1","10","101","1010","100+","100d"};
StringpatternStr="\\d+";
for（Stringstr:
dataArr）{
booleanresult=Pattern.matches（patternStr,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
}else{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"失败"）;
}
}
输出：
字符串1匹配模式\d+成功
字符串10匹配模式\d+成功
字符串101匹配模式\d+成功
字符串1010匹配模式\d+成功
字符串100+匹配模式\d+失败
字符串100d匹配模式\d+失败
注：
d表示字母d,\d表示的是数字，不是字母d,前一个'\'是转义字符，用来转义第二个'\'。
'\d+'表示一个或一个以上数字，所以"\\d+"就表示一位或多位数字，因此前四个能匹配上,最后一个因为+号是非数字字符而匹配不上.
实例六:
String[]dataArr={"a100","b20","c30","df10000","gh0t"};
StringpatternStr="\\w+\\d+";
for（Stringstr:
dataArr）{
booleanresult=Pattern.matches（patternStr,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
} else{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"失败"）;
}
}
输出：
字符串a100匹配模式\w+\d+成功
字符串b20匹配模式\w+\d+成功
字符串c30匹配模式\w+\d+成功
字符串df10000匹配模式\w+\d+成功
字符串gh0t匹配模式\w+\d+失败
模式'\w+'表示一个或一个以上字母，'\d+'表示一个或一个以上数字,'\w+\d+'表示的是以多个单字字符开头,多个数字结尾的字符串,多个两个'\'是转义字符，用来转义后面字符'\'。
因此前四个能匹配上,最后一个因为数字后还含有单字字符而不能匹配.
实例七:
Stringstr="薪水,职位姓名;年龄性别";
String[]dataArr=str.split（"[,\\s;]"）;
for（StringstrTmp:
dataArr）{
System.out.println（strTmp）;
}
等同于：
Stringstr="薪水,职位姓名;年龄性别";
Patternp=Ppile（"[,\\s;]"）;
String[]dataArr=p.split（str）;
for（StringstrTmp:
dataArr）{
System.out.println（strTmp）;
}
输出结果都是：
薪水
职位
姓名
年龄
性别
String类的split函数支持正则表达式,上例中模式能匹配”,”,单个空格,”;”中的一个,split函数能把它们中任意一个当作分隔符,将一个字符串劈
分成字符串数组.
实例八:
Stringstr="2007年12月11日";
Patternp=Ppile（"[年月日]"）;
String[]dataArr=p.split（str）;
for（StringstrTmp:
dataArr）{
System.out.println（strTmp）;
}
Pattern是一个正则表达式经编译后的表现模式,它的split方法能有效劈分字符串.
注意其和String.split（）使用上的不同.
实例九:
Stringstr="10元1000人民币10000元100000RMB";
str=str.replaceAll（"（\\d+）（元|人民币|RMB）","$1￥"）;
System.out.println（str）;
输出结果：
10￥1000￥10000￥100000￥
实例九-1：
Stringstr="10元1000人民币10000元100000RMB";
str=str.replaceAll（"（\\d+）（元|人民币|RMB）","200$2"）;
System.out.println（str）;
输出结果：
200元200人民币200元200RMB
上例中,模式“（\\d+）（元|人民币|RMB）”按括号分成了两组,第一组\\d+匹配单个或多个数字,第二组匹配元,人民币,RMB中的任意一个,替换部分$1表
示第一个组匹配的部分不变,其余组替换成￥.
替换后的str为￥10￥1000￥10000￥100000
实例十:
Patternp=Ppile（"m（o+）n",Pattern.CASE_INSENSITIVE）;
//用Pattern类的matcher（）方法生成一个Matcher对象
Matcherm=p.matcher（"moonmooonMonmooooonMooon"）;
StringBuffersb=newStringBuffer（）;
//使用find（）方法查找第一个匹配的对象
booleanresult=m.find（）;
//使用循环找出模式匹配的内容替换之,再将内容加到sb里
while（result）{
m.appendReplacement（sb,"moon"）;
result=m.find（）;
}
//最后调用appendTail（）方法将最后一次匹配后的剩余字符串加到sb里；
m.appendTail（sb）;
System.out.println（"替换后内容是"+sb.toString（））;
实例10-2：
//Pattern.CASE_INSENSITIVE不区分大小写的匹配
Patternp=Ppile（"java",Pattern.CASE_INSENSITIVE）;
Matcherm=p.matcher（"javakj34kkkkiiiJAVAip34"）;
System.out.println（m.find（））;
System.out.println（m.find（））;
System.out.println（m.find（））;
输出结果：
true
true
false
实例10-3：
Patternp=Ppile（"java",Pattern.CASE_INSENSITIVE）;
Matcherm=p.matcher（"javaJavaJAVaJaVaIloveJAVAyouhateJavaafasdfasdf"）;
StringBufferbuf=newStringBuffer（）;
inti=0;
while（m.find（））{
i++;
if（i%2==0）{
m.appendReplacement（buf,"java"）;
}else{
m.appendReplacement（buf,"JAVA"）;
}
}
System.out.println（buf）;
m.appendTail（buf）;//添加尾巴
System.out.println（buf）;
输出：
JAVAjavaJAVAjavaIloveJAVAyouhatejava
JAVAjavaJAVAjavaIloveJAVAyouhatejavaafasdfasdf
10-4实例：
Patternp=Ppile（"j\\w\\w\\s",Pattern.CASE_INSENSITIVE）;
Matcherm=p.matcher（"javJavaJAVJaVaIloveJAVAJashateJavaafasdfasdf"）;
StringBufferbuf=newStringBuffer（）;
inti=0;
while（m.find（））{
i++;
if（i%2==0）{
m.appendReplacement（buf,"good"）;
}else{
m.appendReplacement（buf,"GOOD"）;
}
}
m.appendTail（buf）;//添加尾巴
System.out.println（buf）;
输出：
GOODJavagoodJaVaIloveJAVAGOODhateJavaafasdfasdf
实例十一:
除了用+表示一次或多次,*表示0次或多次,?
表示0次或一次外,还可以用{}来指定精确指定出现的次数,X{2,5}表示X最少出现2次,最多出现5次;X{2,}表
示X最少出现2次,多则不限;X{5}表示X只精确的出现5次.
例程:
String[]dataArr={"google","gooogle","gooooogle","goooooogle","ggle"};
for（Stringstr:
dataArr）{
StringpatternStr="g（o{2,5}）gle";
booleanresult=Pattern.matches（patternStr,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
}else{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"失败"）;
}
}
输出结果：
字符串google匹配模式g（o{2,5}）gle成功
字符串gooogle匹配模式g（o{2,5}）gle成功
字符串gooooogle匹配模式g（o{2,5}）gle成功
字符串goooooogle匹配模式g（o{2,5}）gle失败
字符串ggle匹配模式g（o{2,5}）gle失败
实例十二:
-表示从..到…,如[a-e]等同于[abcde]
String[]dataArr={"Tan","Tbn","Tcn","Ton","Twn"};
for（Stringstr:
dataArr）{
Stringregex="T[a-c]n";
booleanresult=Pattern.matches（regex,str）;
if（result）{
System.out.println（"字符串"+str+"匹配模式"+regex+"成功"）;
}else{
System.out.println（"字符串"+str+"匹配模式"+regex+"失败"）;
}
}
实例十三:
不区分大小写匹配.
正则表达式默认都是区分大小写的,使用了Pattern.CASE_INSENSITIVE则不对大小写进行区分.
StringpatternStr="ab";
Patternpattern=Ppile（patternStr,Pattern.CASE_INSENSITIVE）;
String[]dataArr={"ab","Ab","AB"};
for（Stringstr:
dataArr）{
Matchermatcher=pattern.matcher（str）;
if（matcher.find（））{
System.out.println（"字符串"+str+"匹配模式"+patternStr+"成功"）;
}
}
实例十四:
使用正则表达式劈分字符串.
注意这里要把复杂的模式写在前面,否则简单模式会先匹配上.
Stringinput="职务=GM薪水=50000,姓名=职业经理人;性别=男年龄=45";
StringpatternStr="（\\s*,\\s*）|（\\s*;\\s*）|（
升级会员 