java之正则表达式

最新推荐文章于 2024-05-30 12:58:04 发布

褚金辉

最新推荐文章于 2024-05-30 12:58:04 发布

阅读量471

点赞数

分类专栏： java 正则表达式文章标签： java 正则表达式

本文链接：https://blog.csdn.net/maosijunzi/article/details/78116102

版权

java 同时被 2 个专栏收录

135 篇文章 2 订阅

订阅专栏

正则表达式

4 篇文章 0 订阅

订阅专栏

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+ $或 ^\w{3,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)? $或 ^\d{8,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*?)[^>]>.?

褚金辉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之正则表达式

使用到的类java操作正则表达式需要用到的类有两个，Pattern和Matcher，Matcher有几个比较重要的方法比如，matches，lookingAt，find,groupCount,group等。下面我们用到的时候会逐一解释。先看个实例：到了下班时间了，今天到此为止，明天继续更新
复制链接

扫一扫