字符串处理是许多程序中非常重要的一部分,它们可以用于文本显示,数据表示,查找键和很多目的.在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匹配input
String[] 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次或多次
+ 重复前面的子模式一次到多次
注意啦：如果字符串本身含有问号'?'，用[?]就可以匹配。
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
str = str.replaceAll("[\\pP‘’“”]", "");
Unicode 编码并不只是为某个字符简单定义了一个编码，而且还将其进行了归类。
\pP 其中的小写 p 是 property 的意思，表示 Unicode 属性，用于 Unicode 正表达式的前缀。
大写 P 表示 Unicode 字符集七个字符属性之一：标点字符。
其他六个是
L：字母；
M：标记符号（一般不会单独出现）；
Z：分隔符（比如空格、换行等）；
S：符号（比如数学符号、货币符号等）；
N：数字（比如阿拉伯数字、罗马数字等）；
C：其他字符
上面这七个是属性，七个属性下还有若干个子属性，用于更进一步地进行细分。
Java 中用于 Unicode 的正则表达式数据都是由 Unicode 组织提供的。
Unicode 正则表达式标准（可以找到所有的子属性）
http://www.unicode.org/reports/tr18/
各 Unicode 字符属性的定义，可以用一看看某个字符具有什么属性。
http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
这个文本文档一行是一个字符，第一列是 Unicode 编码，第二列是字符名，第三列是 Unicode 属性，
以及其他一些字符信息。
以下是实例部分:
实例一:
正则式是最简单的能准确匹配一个给定String的模式,模式与要匹配的文本是等价的.静态的Pattern.matches方法用于比较一个String是否匹配一个给定模式.例程如下:
String data="java";
boolean result=Pattern.matches("java",data);
输出：
true
实例二:
String[] dataArr = { "moon", "mon", "moon", "mono" };
String patternStr="m(o+)n";
boolean result =false;
for (String str : 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"};
String patternStr="b[aeiou]n";
boolean result=false;
for (String str : 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"};
String patternStr="b(ee|ea|oo)n";
for (String str : dataArr) {
boolean result = 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"};
String patternStr="\\d+";
for (String str : dataArr) {
boolean result = 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"};
String patternStr="\\w+\\d+";
for (String str : dataArr) {
boolean result = 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+'表示的是以多个单字字符开头,多个数字结尾的字符串,多个两个'\'是转义字符，用来转义后面字符'\'。因此前四个能匹配上,最后一个因为数字后还含有单字字符而不能匹配.
实例七:
String str="薪水,职位 姓名;年龄 性别";
String[] dataArr =str.split("[,\\s;]");
for (String strTmp : dataArr) {
System.out.println(strTmp);
}
等同于：
String str="薪水,职位 姓名;年龄 性别";
Pattern p = Pattern.compile("[,\\s;]");
String[] dataArr =p.split(str);
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)", "$1￥");
System.out.println(str);
输出结果：
10￥ 1000￥ 10000￥ 100000￥
实例九-1：
String str="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
实例十:
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());
实例10-2：
//Pattern.CASE_INSENSITIVE不区分大小写的匹配
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("javakj34kkkkiiiJAVAip34");
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
输出结果：
true
true
false
实例10-3：
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java Java JAVa JaVa IloveJAVA you hateJava afasdfasdf");
StringBuffer buf = new StringBuffer();
int i=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);
输出：
JAVA java JAVA java IloveJAVA you hatejava
JAVA java JAVA java IloveJAVA you hatejava afasdfasdf
10-4实例：
Pattern p = Pattern.compile("j\\w\\w\\s", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("jav Java JAV JaVa IloveJAVA Jas hateJava afasdfasdf");
StringBuffer buf = new StringBuffer();
int i=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);
输出：
GOOD Java good JaVa IloveJAVA GOOD hateJava afasdfasdf
实例十一:
除了用+表示一次或多次,*表示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 + "失败");
}
}
输出结果：
字符串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 (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);
}
实例十五:解析正则表达式中的文字,\\1对应第一个小括号括起来的group1.
String regex="<(\\w+)>(\\w+)</\\1>";
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());
字符串处理是许多程序中非常重要的一部分,它们可以用于文本显示,数据表示,查找键和很多目的.在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匹配input
String[] 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+就表示一位或多位数字.
因此前四个能匹配上,最后一个因为+号是非数字字符而匹配不上.
实例六:
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)", "$1￥");
System.out.println(str);
上例中,模式“(\\d+)(元|人民币|RMB)”按括号分成了两组,第一组\\d+匹配单个或多个数字,第二组匹配元,人民币,RMB中的任意一个,替换部分$1表
示第一个组匹配的部分不变,其余组替换成￥.
替换后的str为￥10 ￥1000 ￥10000 ￥100000
实例十:
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);
}
实例十五:解析正则表达式中的文字,\\1对应第一个小括号括起来的group1.
String regex="<(\\w+)>(\\w+)</\\1>";
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());
应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：
String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, "");
}
利用正则表达式分解和转换IP地址：
下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：
function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}
不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：
var ip="10.100.20.168"
ip=ip.split(".")
*****("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?
利用正则表达式去除字串中重复的字符的算法程序：
var s="abacabefgeeii"
var s1=s.replace(/(.).*\1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
*****(s1+s2) //结果为：abcefgi
我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。
得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1
s="http://www.9499.net/page1.htm"
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
*****(s)
利用正则表达式限制网页表单里的文本框输入内容：
用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"
用正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"
用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"
用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"
相关推荐
根据提供的文件信息，本文将详细解析如何通过Java编程语言实现计算汉字笔画数的方法，并对代码中的关键逻辑进行深入分析。 ### 概述 在Java中实现计算汉字笔画数的功能，主要涉及到对汉字编码的理解以及如何根据...
【藏文正字检错】藏文正字检错是针对藏文电子文本中存在的字词和语法错误进行检测和纠正的任务，旨在提升藏文电子文本的质量。随着互联网的发展，藏文电子文本的数量激增，而其中的错误也随之增多，因此藏文正字检错...
正则表达式是一种强大的文本处理工具，用于匹配、查找、替换和分析字符串。它由三种基本元素构成：量词、元字符和修饰符。 1. **量词**： - `+`：表示前面的字符至少出现一次。 - `*`：表示前面的字符可以出现...
1. **Java版本**：Java 8是Java的一个重要版本，引入了Lambda表达式、方法引用来简化代码，以及默认方法来增强接口功能。它还改进了日期/时间API，增加了Stream API，提高了性能和并发处理能力。 2. **JDK与JRE的...
在IT行业中，设计装置往往涉及到硬件创新和软件应用的结合，尤其当提到“正书正字器”这样的概念时，我们可以推断这可能是一种专门用于规范书写或打印的设备或系统。这种装置的设计旨在提高文字的准确性和一致性，...
PDF版的，很实用 电脑前没有字典的时候，打开看看吧!
二级下册用正字法整理数据PPT课件.ppt
歉意正字刚做出来的项目 一个简单的QQ聊天工具 有登陆界面，聊天界面，聊天界面上有“好友在现列表” 能实现简单的群聊，私聊等 注：在Util类中 有一个读文件的操作 所以自己创建一个txt文件 存有用户名和密码就可以...
交替正字法中的爱丽丝 我转换了“la alis”。 cizra je cinri zukte vi le selmacygu'e”（“爱丽丝梦游仙境”的 Lojban 翻译）到非标准正字法。 结果以 UTF-8 编码的纯文本格式提供。 这种替代正字法的目标是提供 ...
吕蒙正是北宋时期的著名政治家，字圣功，河南人。他的父亲吕龟图曾担任起居郎，但在家庭生活中，吕龟图偏爱其他姬妾，与刘氏关系不睦，导致吕蒙正和母亲一同被赶出家门，生活困顿。尽管遭受了这些困难，吕蒙正后来...
本项目是一款基于Python和HTML的中华正字Web+App UI自动设计源码，共包含22个文件，其中Python源文件12个，XML配置文件5个。该系统旨在实现正中华Web和App界面的自动化设计，适用于需要高效UI设计的开发者和企业。
场景包
在IT行业中，云技术已经成为企业计算的核心组成部分，而“正字法的受限学习者”这一概念可能是指在云计算环境中的一种特定的学习算法或者模型。这里提到的“统一、分布式和动态”，是云服务的三个关键特性，它们对于...
台湾闽南语卡拉OK正字字表内容说明有鉴于目前坊间闽南语伴唱带，歌词字幕之闽南语用字，常借用华语用词或采用华语借音，造成闽南语汉字使用的混淆。为改善这种混乱情形，教育部特成立「闽南语卡拉OK正字小组」，就...
segment 包提供了 Unicode 标准标记化例程和正字法分段，实现了The Unicode Cookbook (Moran and Cysouw 2018) 中的正字法配置文件规范中描述的线性算法 ）。 命令行使用 创建一个文本文件： $ echo "aäaaöaaü...
ACE中文自动口语印刷和正字错误检测是一项涉及自然语言处理和计算语言学的研究工作，它旨在创建一个能够自动识别并校正中文口语、排印错误和正字错误的系统。这项研究的成果对于提高中文书写准确性和规范化具有重要...
该项目的主要目标是创建一个易于使用的应用程序，帮助人们过渡到新的正字法协议。项目NetBeans 版本：8.0.1 JDK：1.8数据库SQLite编译： 项目属性 -> 库 -> 添加 JAR/文件夹 -> 添加db/sqlite-jdbc-(VERSION).jar...
OrthoInspector是一款专为拼写和参数分析设计的开源软件系统，其核心价值在于为用户提供一个高效、便捷的平台，以安装、维护描述正字和不正字关系的数据库。这款工具的诞生，旨在帮助研究人员和开发者更好地理解和...