java操作正则
java操作正则表达式需要用到的类有两个,Pattern和Matcher,Matcher有几个比较重要的方法比如,matches,lookingAt,find,groupCount,group等。下面我们逐一解释。首先我们给个需求:
匹配字符序列“abacbadb”中“a”和“b”之间的字符(包括a和b),也就是以a开头b结束。并且要求a和b之间的字符尽可能少。
给出正则表达式如下,不了解正则表达式的同学,现在可以不必理会这个表达式的内容,之后会一一降到。为了使用分组我特意加上了括号:
(a.*?)(b)
我们先找到字符序列中所有满足需求的字符子序列,如下:
- ab
- abacb
- abacbadb
- acb
- acbadb
- adb
另外需要提前说明的是,Matcher类有三种匹配方法,分别如下:
- matches:方法尝试将整个输入序列与该模式匹配。
- lookingAt:尝试将输入序列从头开始与该模式匹配。
- find:方法扫描输入序列以查找与该模式匹配的下一个子序列
使用matches方法匹配
先看代码:
String regex = "(a.*?)(b)";//此正则表达式
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
System.out.println("matches:"+matcher.matches());//是否匹配成功
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));//匹配结果
System.out.println("matches:"+matcher.matches());//是否匹配成功
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));//匹配结果
System.out.println("matches:"+matcher.matches());//是否匹配成功
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));//匹配结果
输出结果如下:
matches:true
result:abacbadb
matches:true
result:abacbadb
matches:true
result:abacbadb
代码我们看出,我们连续匹配了三次,而且三次匹配的结果都一样。都是第三种子序列,因为matches方法是整体匹配的,也就是说会把整个字符序列和正则表达式进行匹配。那么abacbadb是满足正则表达式的所以返回true以及整个字符序列。我们再看一个例子,加深一下整体匹配的印象:
String regex = "^a";//此正则表达式表示以a开头
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
System.out.println("matches:"+matcher.matches());//是否匹配成功
例子中正则表达式“^a”是要匹配所有以a开头的字符串。给出的字符序列确实是以a开头,那么匹配结果是true了。这么想是没有错,但是运行程序输出结果如下:
matches:false
我们看到匹配的结果是false。为什么是false?原因就在于matches方法是整体匹配的,调用matches方法的时候程序会看到字符序列是以abacbadb开头的,并不是a。可能理解有点绕和其他方法比较一下更有助于理解。下面我们看另外两个方法。
使用lookingAt方法匹配
你可以使用matcher.reset()方法重置后,继续使用lookingAt进行匹配。不过我们这里为了代码清晰,重新写一套,代码如下所示:
String regex = "(a.*?)(b)";//此正则表达式
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
System.out.println("lookingAt:"+matcher.lookingAt());//匹配
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));//匹配结果
System.out.println("lookingAt:"+matcher.lookingAt());//匹配
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));//匹配结果
System.out.println("lookingAt:"+matcher.lookingAt());//匹配
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));//匹配结果
输出结果如下:
lookingAt:true
result:ab
lookingAt:true
result:ab
lookingAt:true
result:ab
lookingAt是从头开始匹配字符序列,找到第一个匹配的结果就返回,所以我们匹配三次都是得到第一种结果ab。这个方法很好理解,就不在多说,继续看下一个方法。
使用find方法匹配
代码如下所示:
String regex = "(a.*?)(b)";//此正则表达式
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
System.out.println("find:"+matcher.find());
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));
System.out.println("find:"+matcher.find());
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));
System.out.println("find:"+matcher.find());
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));
输出结果如下:
find:true
result:ab
find:true
result:acb
find:true
result:adb
可以看到,三次匹配得到三种不同的结果。就像find定义那样,是从开头开始逐个扫描字符序列,找到所有符合正则的结果。
分组的使用
简单的说,一个括号就是一个分组,那么正则表达式(a.*?)(b)中就有两个分组,两个分组的匹配结果构成了整个正则表达式的匹配结果。正则表达式会把整个表达式也作为一个分组,而且是放在第一个位置,所以这个正则中共有三个分组,如下:
- 第一个分组:(a.*?)(b)
- 第二个分组:(a.*?)
- 第三个分组:(b)
不了解分组的后面我们还会介绍。这里我们先看一下java代码中分组的使用,代码如下:
String regex = "(a.*?)(b)";//此正则表达式
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
while(matcher.find()){
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));
int groupCount = matcher.groupCount();//分组数量
for(int i=0;i<=groupCount;i++){
System.out.println("group["+i+"]="+matcher.group(i));//每个分组匹配内容
}
}
输出结果如下:
result:ab
group[0]=ab
group[1]=a
group[2]=b
result:acb
group[0]=acb
group[1]=ac
group[2]=b
result:adb
group[0]=adb
group[1]=ad
group[2]=b
从输出结果,我们看到了匹配结果以及每个分组的匹配结果。每个匹配结果都对应三个分组,这和我们上边提到的符合。
如何匹配全部子串
正则表达式只存在两种模式:贪婪模式和非贪婪模式。贪婪模式就是尽可能多的匹配对应的就是matches方法(全局匹配),非贪婪模式就是从开头逐个匹配,也就是对应find方法。所以说没有匹配所有子串的方法。那么我们就只能自行找办法来解决这个办法了,代码如下所示:
String regex = "(a.*?)(b)";//此正则表达式
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
for(int i=0;i<input.length();i++){
for(int j=i+1;j<=input.length();j++){
matcher.reset();//重置matcher
Matcher region = matcher.region(i, j);//设置匹配区域
if(region.matches()){//匹配
System.out.println("result:"+input.substring(matcher.start(), matcher.end()));
}
}
}
输出结果如下所示:
result:ab
result:abacb
result:abacbadb
result:acb
result:acbadb
result:adb
这种办法,如果字符序列很长的话,会很消耗时间。可以自行寻找其他办法来解决此问题
对于java操作正则表达式我们就说这么多,下面我们具体来看正则表达式。
正则表达式语法
元字符
元字符 | 说明 |
---|---|
^ | 表示以某字符开头 |
$ | 标识以某字符结尾 |
. | 表示任何字符 |
代码如下所示:
String regex = "^a";//此正则表达式
String input = "abacbadb";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
System.out.println(input+"是否以a开头:"+matcher.find());
regex = "b$";
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(input+"是否以b结尾:"+matcher.find());
regex = "^a.";
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(input+"是否以a开头,后跟任意字符:"+matcher.find());
输出结果如下:
abacbadb是否以a开头:true
abacbadb是否以b结尾:true
abacbadb是否以a开头,后跟任意字符:true
贪婪模式
字符 | 说明 |
---|---|
+ | 出现一次或多次 |
* | 出现零次或多次 |
? | 出现零次或一次 |
{m} | 出现m次 |
{m,n} | 出现m到n次 |
{m,} | 出现m次以上 |
实例代码如下:
String regex = "a+";//此正则表达式
String input = "aaaaa";//字符序列
Pattern pattern = Pattern.compile(regex);//编译正则
Matcher matcher = pattern.matcher(input);//匹配字符序列
System.out.println(matcher.matches());
regex = "a*";//此正则表达式
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(matcher.matches());
regex = "a?";//此正则表达式
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(matcher.matches());
regex = "a{5}";//此正则表达式
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(matcher.matches());
regex = "a{1,6}";//此正则表达式
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(matcher.matches());
regex = "a{6,}";//此正则表达式
pattern = Pattern.compile(regex);//编译正则
matcher = pattern.matcher(input);//匹配字符序列
System.out.println(matcher.matches());
输出结果如下:
true
true
false
true
true
false
非贪婪模式
字符 | 说明 |
---|---|
+? | 重复1次或更多次,但尽可能少重复 |
*? | 重复任意次,但尽可能少重复 |
?? | 重复0次或1次,但尽可能少重复 |
{n,m}? | 重复n到m次,但尽可能少重复 |
{n,}? | 重复n次以上,但尽可能少重复 |
代码实例如下:
String input = "<b>welcome</b><b>t</b><b>phpfuns</b>";
Pattern pattern = Pattern.compile("<b>.*?</b>");
Matcher matcher = pattern.matcher(input);
if(matcher.find()){
System.out.println(input.substring(matcher.start(),matcher.end()));
}
pattern = Pattern.compile("<b>.+?</b>");
matcher = pattern.matcher(input);
if(matcher.find()){
System.out.println(input.substring(matcher.start(), matcher.end()));
}
pattern = Pattern.compile("<b>.??</b>");
matcher = pattern.matcher(input);
if(matcher.find()){
System.out.println(input.substring(matcher.start(), matcher.end()));
}
pattern = Pattern.compile("<b>.{3,10}?</b>");
matcher = pattern.matcher(input);
if(matcher.find()){
System.out.println(input.substring(matcher.start(), matcher.end()));
}
pattern = Pattern.compile("<b>.{3,}?</b>");
matcher = pattern.matcher(input);
if(matcher.find()){
System.out.println(input.substring(matcher.start(), matcher.end()));
}
输出结果如下所示:
<b>welcome</b>
<b>welcome</b>
<b>t</b>
<b>welcome</b>
<b>welcome</b>
分组
上面介绍过,单个字符的重复可以用 + * ? 来表示,如果是多个字符的重复怎么办呢?此时就要引入分组。用一个括号括起来,比如(abc)+表示abc重复1次或多次。分组可以分为两种形式,捕获组和非捕获组。
代码如下所示:
String input = "abcabc";
Pattern pattern = Pattern.compile("(abc)+");
Matcher matcher = pattern.matcher(input);
System.out.println(matcher.matches());
pattern = Pattern.compile("(abc)?");
matcher = pattern.matcher(input);
System.out.println(matcher.matches());
pattern = Pattern.compile("(abc)*");
matcher = pattern.matcher(input);
System.out.println(matcher.matches());
输出结果如下:
true
false
true
捕获组
可以通过从左到右计算其开括号来编号 。例如,在表达式 (A)(B(C)) 中,存在四个这样的组:
- 分组0: (A)(B(C))
- 分组1: (A)
- 分组2: (B(C))
- 分组3: (C)
代码如下所示:
String input = "abcabc";
Pattern pattern = Pattern.compile("(a(b(c)))");
Matcher matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("group result:"+input.substring(matcher.start(),matcher.end()));
int groupCount = matcher.groupCount();
for(int i = 1;i<=groupCount;i++){
System.out.println("group["+i+"]="+matcher.group(i));
}
}
输出结果如下所示:
group result:abc
group[1]=abc
group[2]=bc
group[3]=c
group result:abc
group[1]=abc
group[2]=bc
group[3]=c
非捕获组
以 (?) 开头的组是纯的非捕获 组,它不捕获文本 ,也不针对组合计进行计数。非捕获组有很多种形式,其中包括:零宽度断言和模式修正符.
零宽度断言.
- a(?=b):零宽度正先行断言:除非a后跟着b才匹配a
- a(?!b):零宽度负先行断言.除非a后不跟着b才匹配a
- (?<=a)b:零宽度正后发断言.除非b前是a才匹配b
- (?< !a)b:零宽度负后发断言.除非b前不是a才匹配b
代码如下所示:
String input = "aabb3 ddfd4";
Pattern pattern = Pattern.compile("\\w+(?=\\d)");
Matcher matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("result1:"+input.substring(matcher.start(),matcher.end()));
}
input = "aabb3 ddfd4";
pattern = Pattern.compile("\\w+(?!\\d)");
matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("result2:"+input.substring(matcher.start(),matcher.end()));
}
input = "abbbb";
pattern = Pattern.compile("(?<=a)b");
matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("result3:"+input.substring(matcher.start(),matcher.end()));
}
input = "abcbdb";
pattern = Pattern.compile("(?<!a)b");
matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("result4:"+input.substring(matcher.start(),matcher.end()));
}
输出结果如下:
result1:aabb
result1:ddfd
result2:aabb3
result2:ddfd4
result3:b
result4:b
result4:b
模式修正符
- (?i):不区分大小写
- (?m):多行匹配
- (?s):如果没有使用这个模式修正符号,元字符中的”.”默认不能表示换行符号,将字符串视为单行
- (?x):表示模式中的空白忽略不计
String input = "ABabaBAb";
Pattern pattern = Pattern.compile("(?i)ab");
Matcher matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("matcher1:"+input.substring(matcher.start(),matcher.end()));
}
input = "ab\nab\nab";
pattern = Pattern.compile("(?m)ab");
matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("matcher2:"+input.substring(matcher.start(),matcher.end()));
}
input = "a\nc";
pattern = Pattern.compile("(?s)a.c");
matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("matcher3:"+input.substring(matcher.start(),matcher.end()));
}
input = "ac";
pattern = Pattern.compile("(?x)a c");
matcher = pattern.matcher(input);
while(matcher.find()){
System.out.println("matcher4:"+input.substring(matcher.start(),matcher.end()));
}
赎出结果如下:
matcher1:AB
matcher1:ab
matcher1:aB
matcher1:Ab
matcher2:ab
matcher2:ab
matcher2:ab
matcher3:a
c
matcher4:ac
或者关系
(x|y)表达式表示x和y两者出现其中一个。代码如下:
public static boolean matches(String regex, String input) {
return input.matches(regex);
}
//(a|b)c:表示ac或者bc
System.out.println(matches("(a|b)c","ac"));
System.out.println(matches("(a|b)c","bc"));
//(a|b)*c:表示一串a和b混合的字符串后跟一个c
System.out.println(matches("(a|b)*c","c"));
System.out.println(matches("(a|b)*c","ac"));
System.out.println(matches("(a|b)*c","bc"));
System.out.println(matches("(a|b)*c","aaabbbababac"));
输出结果如下:
true
true
true
true
true
true
中括号
[]:某些字符允许在一个字符串中的某一特定位置出现。^出现再[]中第一个位置表示不能出现的字符。
public static boolean find(String regex, String input) {
Pattern pattern = Pattern.compile(regex);
return pattern.matcher(input).find();
}
//[ab]:表示a或者b
System.out.println(matches("[ab]","b"));
System.out.println(matches("[ab]","a"));
//[a-d]:表示从a到d的任意一个
System.out.println(matches("[a-d]","c"));
//[a-zA-Z]:表示一个字母
System.out.println(matches("[a-zA-Z]","g"));
System.out.println(matches("[a-zA-Z]","F"));
//,[0-9]$:表示字符串已逗号跟一个数字结束
System.out.println(find(",[0-9]$","a,9"));
// a[^a-zA-Z]:表示a后不能跟一个字母
System.out.println(matches("a[^a-zA-Z]","ab"));
System.out.println(matches("a[^a-zA-Z]","a9"));
输出结果如下:
true
true
true
true
true
true
false
true
转义字符
如果要匹配的字符是正则语法中的字符,那么就需要用反斜杠来转义,这点不必细说。有一些特殊的转义字符,如下:
字符 | 说明 |
---|---|
\b | 不会消耗任何字符只匹配一个位置,常用于匹配单词边界 |
\d | 匹配数字 |
\w | 匹配单词,字母,数字,下划线 |
\s | 匹配空格。 |
实例如下:
System.out.println(find("\\bis\\b", "this is bird"));
System.out.println(matches("0\\d{3}-\\d{7}", "0150-1234567"));
System.out.println(matches("0\\w{3}-\\w{7}", "0150-1234567"));
System.out.println(matches("0\\w{3}-\\w{7}", "0a_c-123_abc"));
System.out.println(matches("(\\w\\s){3}", "a 2 _ "));
输出如下:
true
true
true
true
true
一些常用的正则表达式
数字
1 数字:^[0-9]*$
2 n位的数字:^\d{n}$
3 至少n位的数字:^\d{n,}$
4 m-n位的数字:^\d{m,n}$
5 零和非零开头的数字:^(0|[1-9][0-9]*)$
6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)+(.[0-9]{1,2})?$
7 带1-2位小数的正数或负数:^(-)?\d+(.\d{1,2})?$
8 正数、负数、和小数:^(-|+)?\d+(.\d+)?$
9 有两位小数的正实数:^[0-9]+(.[0-9]{2})?$
10 有1~3位小数的正实数:^[0-9]+(.[0-9]{1,3})?$
11 非零的正整数:^[1-9]\d* 或([1−9][0−9]∗)1,3 或 ^+?[1-9][0-9]*$
12 非零的负整数:^-[1-9][]0-9”* 或−[1−9]\d∗
13 非负整数:^\d+ 或[1−9]\d∗|0
14 非正整数:^-[1-9]\d*|0 或((−\d+)|(0+))
15 非负浮点数:^\d+(.\d+)? 或[1−9]\d∗\.\d∗|0\.\d∗[1−9]\d∗|0?\.0+|0
16 非正浮点数:^((-\d+(.\d+)?)|(0+(.0+)?)) 或(−([1−9]\d∗\.\d∗|0\.\d∗[1−9]\d∗))|0?\.0+|0
17 正浮点数:^[1-9]\d*.\d*|0.\d*[1-9]\d* 或(([0−9]+\.[0−9]∗[1−9][0−9]∗)|([0−9]∗[1−9][0−9]∗\.[0−9]+)|([0−9]∗[1−9][0−9]∗))
18 负浮点数:^-([1-9]\d*.\d*|0.\d*[1-9]\d*) 或(−(([0−9]+\.[0−9]∗[1−9][0−9]∗)|([0−9]∗[1−9][0−9]∗\.[0−9]+)|([0−9]∗[1−9][0−9]∗)))
19 浮点数:^(-?\d+)(.\d+)? 或−?([1−9]\d∗\.\d∗|0\.\d∗[1−9]\d∗|0?\.0+|0)
校验字符的表达式
1 汉字:^[\u4e00-\u9fa5]{0,}$
2 英文和数字:^[A-Za-z0-9]+ 或[A−Za−z0−9]4,40
3 长度为3-20的所有字符:^.{3,20}$
4 由26个英文字母组成的字符串:^[A-Za-z]+$
5 由26个大写英文字母组成的字符串:^[A-Z]+$
6 由26个小写英文字母组成的字符串:^[a-z]+$
7 由数字和26个英文字母组成的字符串:^[A-Za-z0-9]+$
8 由数字、26个英文字母或者下划线组成的字符串:^\w+ 或\w3,20
9 中文、英文、数字包括下划线:^[\u4E00-\u9FA5A-Za-z0-9_]+$
10 中文、英文、数字但不包括下划线等符号:^[\u4E00-\u9FA5A-Za-z0-9]+ 或[\u4E00−\u9FA5A−Za−z0−9]2,20
11 可以输入含有^%&’,;=?\"等字符:[^%&',;=?\x22]+
12 禁止输入含有~的字符:[^~\x22]+
特殊需求表达式
1 Email地址:^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$
2 域名:[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3 InternetURL:[a-zA-z]+://[^\s]* 或 ^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$
4 手机号码:^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5 电话号码(“XXX-XXXXXXX”、”XXXX-XXXXXXXX”、”XXX-XXXXXXX”、”XXX-XXXXXXXX”、”XXXXXXX”和”XXXXXXXX):^((\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6 国内电话号码(0511-4405222、021-87888822):\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号(15位、18位数字):^\d{15}|\d{18}$
8 短身份证号码(数字、字母x结尾):^([0-9]){7,18}(x|X)? 或\d8,18|[0−9x]8,18|[0−9X]8,18?
9 帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10 密码(以字母开头,长度在6~18之间,只能包含字母、数字和下划线):^[a-zA-Z]\w{5,17}$
11 强密码(必须包含大小写字母和数字的组合,不能使用特殊字符,长度在8-10之间):^(?=.\d)(?=.[a-z])(?=.*[A-Z]).{8,10}$
12 日期格式:^\d{4}-\d{1,2}-\d{1,2}
13 一年的12个月(01~09和1~12):^(0?[1-9]|1[0-2])$
14 一个月的31天(01~09和1~31):^((0?[1-9])|((1|2)[0-9])|30|31)$
15 钱的输入格式:
16 1.有四种钱的表示形式我们可以接受:”10000.00” 和 “10,000.00”, 和没有 “分” 的 “10000” 和 “10,000”:^[1-9][0-9]*$
17 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符”0”不通过,所以我们采用下面的形式:^(0|[1-9][0-9]*)$
18 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号:^(0|-?[1-9][0-9]*)$
19 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分:^[0-9]+(.[0-9]+)?$
20 5.必须说明的是,小数点后面至少应该有1位数,所以”10.”是不通过的,但是 “10” 和 “10.2” 是通过的:^[0-9]+(.[0-9]{2})?$
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样:^[0-9]+(.[0-9]{1,2})?$
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样:^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
23 8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须:^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
24 备注:这就是最终结果了,别忘了”+”可以用”*”替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
25 xml文件:^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x|X][m|M][l|L]$
26 中文字符的正则表达式:[\u4e00-\u9fa5]
27 双字节字符:[^\x00-\xff] (包括汉字在内,可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1))
28 空白行的正则表达式:\n\s*\r (可以用来删除空白行)
29 HTML标记的正则表达式:<(\S*?)[^>]>.?