java正则表达式详解

时间:2023-01-16 04:40:47

正则表达式:

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。

Java 正则表达式和 Perl的是最为相似的。

java.util.regex包主要包括以下三个类:

·        Pattern类:

pattern 对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个 Pattern对象,你必须首先调用其公共静态编译方法,它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数。

·        Matcher类:

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样,Matcher也没有公共构造方法。你需要调用 Pattern对象的 matcher方法来获得一个 Matcher对象。

·        PatternSyntaxException

PatternSyntaxException 是一个非强制异常类,它表示一个正则表达式模式中的语法错误。

 

         定义一个比较规则,用该规则去匹配想要匹配的东西,返回结果。

创建方式:


 

//创建正则对象
//调用静态方法compile方法,传参正则语句
String regex = "abcd";
String text = "++abcdabcd++";
Pattern pattern = Pattern.compile(regex);
//matcher匹配器对象
Matcher matcher = pattern.matcher(text);

进行匹配功能方法:find()查找,group()返回本次查找到的内容

java正则表达式详解

注意,当find查找返回false时,再去执行group方法,就不会返回String,而是直接报错,所以我们应该在执行group方法的时候进行一次判断。

 

 //进行匹配操作,返回匹配结果
//第一次默认从头开始查找
boolean bool= matcher.find();
System.out.println(bool? "匹配成功" : "匹配失败");
//查看匹配到的文本
String result = matcher.group();
System.out.println(result);
//第二次从上一次查找位置开始查找
bool=matcher.find();
System.out.println(bool? "匹配成功" : "匹配失败");
//获取匹配到的文本
result = matcher.group();
System.out.println(result);
//第三次从上一次查找位置开始查找
bool=matcher.find();
System.out.println(bool? "匹配成功" : "匹配失败");
//获取匹配到的文本,发现本次find查找失败,查看group返回结果,报错
//result = matcher.group();
//System.out.println(result);
//改造一下,我们在执行该方法时,进行一次if判断
if(bool){
result= matcher.group();
System.out.println(result);
}

到目前为止,以上代码已经是查找到了末尾,如果我想再次从指定位置查找,可以执行find(int index)方法,从指定位置进行查找,则又能查找成功。

               

   //从指定位置开始查找          
bool=matcher.find(0);
//匹配成功
System.out.println("从指定位置开始匹配"+ (bool ? "匹配成功" : "匹配失败"));
result= matcher.group();
System.out.println(result);

start()和end()方法

start():返回匹配到文本第一位所在的索引

end():返回匹配到的文本末尾之后一位的索引

   

         //执行匹配方法
bool=matcher.find();
System.out.println("从指定位置开始匹配"+ (bool ? "匹配成功" : "匹配失败"));
result= matcher.group();
System.out.println(result);
//查看一下匹配到文本内容的开始位置
start= matcher.start();
System.out.println("匹配到的开始位置:"+ start);
//查看一下匹配到的文本的结束位置后一位
end= matcher.end();
System.out.println("匹配到的结尾位置:"+ end);
LookingAt()方法:从被匹配文本开始进行匹配,如果开始不满足正则表达式,则返回false,满足返回true。
//从开始位置进行匹配:lookingAt()
regex= "abcd";
text= "sdasdfasdfasfdaabcdefg";
pattern= Pattern.compile(regex);
matcher= pattern.matcher(text);
bool= matcher.lookingAt();
//返回失败,因为text开头并不是abcd
System.out.println("从开始进行匹配"+ (bool ? "匹配成功" : "匹配失败"));

        

全匹配模式matcher()对整个匹配的文本进行匹配,返回布尔值:

//正则表达式匹配整个字符串
text= "abcd";
matcher= pattern.matcher(text);
bool= matcher.matches();
System.out.println("全匹配" +(bool ? "匹配成功" : "匹配失败"));
//返回创建匹配器对象的pattern对象
Pattern pattern2 = matcher.pattern();
//比较返回的pattern2是否与创建mathcer对象的pattern一致
System.out.println((pattern== pattern2)?"与创建本matcher的对象是同一个对象":"其他对象");//true


 

替换第一个匹配到的内容replaceFirst:

          

         //替换第一个匹配到的文本replaceFirst
regex= "abcd";
text= "sabcdabcdg";
pattern= Pattern.compile(regex);
matcher= pattern.matcher(text);
String rfResult = matcher.replaceFirst("替换的文本");
System.out.println("替换后的文本:"+rfResult);

Reset()重置匹配器matcher对象后,再次执行后,从开始进行匹配

           

//重置匹配器,返回本身对象
//执行到这一步,匹配的文本内容是:s替换的文本abcdg
boolean boo = matcher.find();//true
System.out.println("第一次查找"+boo);
boo= matcher.find();//false
System.out.println("第二次查找"+boo);
Matcher restMatcher = matcher.reset();
System.out.println("调用reset方法返回的对象其实就是本对象" + (restMatcher == matcher));
boo= matcher.find();
System.out.println("第三次查找"+boo);//true
//查看匹配器的信息,没啥用
System.out.println(matcher.toMatchResult());
appendReplacement()使用指定字符串替换文本中匹配到的内容,并返回最后匹配到的内容之前的内容。
//appendReplacement(StringBuffersb, String replacement) 从头开始查找并替换匹配到的内容,直到匹配到最后一位,并且将从头到该位的内容输入到sb中
regex= "abcd";
text= "+++++abcd+++++abcd++++";
pattern= Pattern.compile(regex);
matcher= pattern.matcher(text);
String Buffersb = new StringBuffer();
while(matcher.find()){
matcher.appendReplacement(sb,"X");
}
System.out.println("从开始替换匹配文本到结束:"+ sb);

appendTail():我们发现,使用替换方法,后面的内容没了,那么就可以使用该方法,将之后的内容添加到sb缓冲区中。

              

   //appendTail将之前匹配到最后一次文本的之后内容加到sb中
matcher.appendTail(sb);
System.out.println("将之前匹配到最后一次的位置之后的文本也加入到sb中:" + sb);

 

接下来看一下常用的正则语句是如何使用的:

下面表格是从网上抄的,表格之后附有我敲的代码供参考:

\

将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"n"匹配字符"n""\n"匹配换行符。序列"\\"匹配"\""\("匹配"("

^

匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^还会与"\n""\r"之后的位置匹配。

$

匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$还会与"\n""\r"之前的位置匹配。

*

零次或多次匹配前面的字符或子表达式。例如,zo*匹配"z""zoo"*等效于 {0,}

+

一次或多次匹配前面的字符或子表达式。例如,"zo+""zo""zoo"匹配,但与"z"不匹配。+等效于 {1,}

?

零次或一次匹配前面的字符或子表达式。例如,"do(es)?"匹配"do""does"中的"do"?等效于 {0,1}

{n}

是非负整数。正好匹配 n 次。例如,"o{2}""Bob"中的"o"不匹配,但与"food"中的两个"o"匹配。

{n,}

是非负整数。至少匹配 次。例如,"o{2,}"不匹配"Bob"中的"o",而匹配"foooood"中的所有 o"o{1,}"等效于"o+""o{0,}"等效于"o*"

{n,m}

M  n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。例如,"o{1,3}"匹配"fooooood"中的头三个 o'o{0,1}'等效于 'o?'。注意:您不能将空格插入逗号和数字之间。

?

当此字符紧随任何其他限定符(*+?{n}{n,}{n,m})之后时,匹配模式是"非贪心的""非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如,在字符串"oooo"中,"o+?"只匹配单个"o",而"o+"匹配所有"o"

.

匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。

(pattern)

匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用"\("或者"\)"

(?:pattern)

匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如,'industr(?:y|ies)是比 'industry|industries'更经济的表达式。

(?=pattern)

执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?=95|98|NT|2000)'匹配"Windows 2000"中的"Windows",但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

(?!pattern)

执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?!95|98|NT|2000)'匹配"Windows 3.1"中的 "Windows",但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

x|y

匹配 x  y。例如,'z|food'匹配"z""food"'(z|f)ood'匹配"zood""food"

[xyz]

字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"

[^xyz]

反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain""p""l""i""n"

[a-z]

字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a""z"范围内的任何小写字母。

[^a-z]

反向范围字符。匹配不在指定的范围内的任何字符。例如,"[^a-z]"匹配任何不在"a""z"范围内的任何字符。

\b

匹配一个字边界,即字与空格间的位置。例如,"er\b"匹配"never"中的"er",但不匹配"verb"中的"er"

\B

非字边界匹配。"er\B"匹配"verb"中的"er",但不匹配"never"中的"er"

\cx

匹配 x 指示的控制字符。例如,\cM匹配 Control-M或回车符。x 的值必须在 A-Z a-z 之间。如果不是这样,则假定 c 就是"c"字符本身。

\d

数字字符匹配。等效于 [0-9]

\D

非数字字符匹配。等效于 [^0-9]

\f

换页符匹配。等效于 \x0c \cL

\n

换行符匹配。等效于 \x0a \cJ

\r

匹配一个回车符。等效于 \x0d \cM

\s

匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v]等效。

\S

匹配任何非空白字符。与 [^ \f\n\r\t\v]等效。

\t

制表符匹配。与 \x09 \cI等效。

\v

垂直制表符匹配。与 \x0b \cK等效。

\w

匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。

\W

与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。

\xn

匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,"\x41"匹配"A""\x041""\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。

\num

匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,"(.)\1"匹配两个连续的相同字符。

\n

标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n 是八进制转义码。

\nm

标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获,则 n 是反向引用,后面跟有字符 m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 n m 是八进制数字 (0-7)

\nml

 n 是八进制数 (0-3)m  l 是八进制数 (0-7) 时,匹配八进制转义码 nml

\un

匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9匹配版权符号 (©)

       下面代码是我对上表的一个简单的练习:  

import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class TestRegex2{
public static void main(String[] args){

//匹配字符
String regex = "abc";
String text ="aaabcddfabcasf";


//[abc]匹配括号中一个成员
String regex = "[abc]";
String text ="afacsbdfa";

//在中括号中代表非,除了该括号字符之外任意字符
String regex = "[^abc]";
String text ="a1f-acs+bd4Wfa";

//取范围内字符[a-zA-Z][a-z][1-9]
String regex = "[1-9a-e]";
String text ="a1f-acs+bd4Wfa";

//并集
String regex = "[a-c[f-l]]";
String text ="a1f-acs+bd4fjklWfzzzxxa";

//交集 取 a-f 和e-j 的交集 ef
String regex = "[a-f&&[e-j]]";
String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";

//取a-z,不包含e-f字母
//[^e-f]:除了e、f所有的字母、数字、符号
String regex = "[a-z&&[^e-f]]";
String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";

//.:任何字符
String regex = ".";
String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";

//\d:数字0-9 ;\w:a-zA-Z_0-9;\s:空白字符,3个字母的大写相当于取反
String regex = "\\d";
String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";

//^:以之后的字符进行开始进行匹配,放在语句第一位
//$:行的结尾,以前面字符做匹配
String regex = "......a$";
String text ="aaa-aaa";

//匹配次数 ?:0或1次,+:1次及以上,*:0次及以上
String regex = "a+";
String text ="bbbb";

//{n}:代表前面字符出现n次,{n,}:n次及以上,{n,m}n~m次
String regex = "[1-9]\\d{17}";
String text ="112345678912345678";

//验证QQ 5~10
String regex = "[1-9]\\d{4,9}$";
String text ="10086231231231231213231231";

//|:或者
String regex = "abc|ABC|XXX";
String text ="ABCabcadfXXXasABCdabcf";

//验证身份证号
String regex = "[1-9]\\d{17}|[1-9]\\d{14}";
String text ="142212199812122222";

//验证QQ号
String regex = "[1-9]\\d{4,9}";
String text ="12345";

//验证手机号
String regex = "^1[3|5|7|8|9]\\d{9}";
String text ="15666666661";

//验证邮箱 邮箱名为6-20位,邮箱服务商域名2~10位,结尾只能匹配com,net,cn格式
String regex = "^\\w{6,20}@\\w{2,10}\\.com|net|cn";
String text ="155aaaqq@qq.com";


//验证网址http://www.开头,域名主体为1-10位a-zA-Z0-9字符,结尾只能是以.com cn net org xin结尾的网址
String regex = "^http://w{3}\\.\\w{1,10}\\.com|cn|net|org|xin";
String text ="http://www.sohu.com";

//验证账号:a-zA-Z0-9_$,必须以字母打头,6-16位
String regex = "^\\w[\\w|_|$|\\d]{5,15}";
String text ="httpww";

//验证生日 格式 1999-12-12,月份不能大于12,月份中的日期不能大于31
String regex = "^[12]\\d{3}-[01]\\d-([12]\\d)|(3[01])";
String text ="1991-12-32";


//创建正则对象
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
System.out.println(matcher.matches()?"匹配成功":"匹配失败") ;

//输出匹配的内容
while(matcher.find()){
Stringresult = matcher.group();
System.out.println(result);
}

}
}


匹配器对象Matcher的替换方法: 

 

//appendReplacement(StringBuffersb, String replacement) 从头开始查找并替换匹配到的内容,直到匹配到最后一位,并且将从头到该位的内容输入到sb中       
regex= "abcd";
text= "+++++abcd+++++abcd++++";
pattern= Pattern.compile(regex);
matcher= pattern.matcher(text);
StringBuffer sb = new StringBuffer();
while(matcher.find()){
matcher.appendReplacement(sb,"X");
}
System.out.println("从开始替换匹配文本到结束:"+ sb);
//appendTail将之前匹配到最后一次文本的之后内容加到sb中
matcher.appendTail(sb);
System.out.println("将之前匹配到最后一次的位置之后的文本也加入到sb中:" + sb);

分组语句: 

  //分组语句(),结合group方法,传参获取指定组的匹配内容
/
*如下正则语句,将会匹配text文本的前11位字符,是没有问题的
*String regex = "至尊宝至尊小宝至尊大宝";
/
//但是,我现在加上括号以后,匹配的结果和没有加括号一样,都是前11位字符
String regex = "(至尊宝)(至尊小宝)(至尊大宝)";
String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
if(matcher.find ()){
Stringgroup = matcher.group();
System.out.println(group);

}


那么,区别在哪儿?既然是分组语句,那么我们可以从匹配器的group方法中看到区别,在api中,group是可以传参的,传参int类型,当传入x数值时,那么返回的将会是正则语句中第x个括号中的匹配内容,当传入0时,返回整个匹配到的语句,如下案例: 


//我现在加上括号以后,匹配的结果和没有加括号一样,都是前11位字符
String regex = "(至尊宝)(至尊小宝)(至尊大宝)";
String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
if(matcher.find ()){
//打印结果为至尊宝
//String group = matcher.group(1);
//System.out.println(group);

//打印结果为至尊小宝
String group = matcher.group(2);
System.out.println(group);


//打印结果为:至尊宝至尊小宝至尊大宝
String group = matcher.group(0);
System.out.println(group);

}


注意:如果group传入的参数的分组序号并不存在,如正则语句只分了2个组,但是group语句访第3个子语句,就会报错!

 其实分组语句还有一个好处,就是给语句进行分组,达到优先级匹配的效果,如下是我写的一个正则语句匹配身份证号,当然并不是那么完美,但是可以看出,下面的分组语句也起到了优先级的效果:

String regex = "^[1-9]\\d{5}(19[0-9]{2}|200[0-9]|201[0-7])(0[0-9]|1[0-2])([012][0-9]|3[01])\\d{3}[0-9|X]";
String text ="35123429800231112X";

预测语句:

//(?:)向后匹配并将其作为捕获的内容
//语法解析:至尊后面只要有大宝、玉、小宝3个成员中的一个,就可以匹配成功,并且将括号中的成员也作为匹配到的内容,如下案例,匹配到的内容就是至尊大宝、至尊玉、至尊小宝:
String regex = "至尊(?:大宝|玉|小宝)";
String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
if(matcher.find()){
String group = matcher.group();
System.out.println(group);

}
//(?=)向后匹配,预测语句其后包含括号中内容,但不捕获
//语法解析,至尊后面只要有大宝、玉、小宝三个成员中的一个,就会匹配成功,但是匹配结果并不会包含这三个成员,也就是说,该语句的匹配到的内容是:至尊、至尊、至尊
String regex = "至尊(?=大宝|玉|小宝)";
String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";
Pattern pattern = Pattern.compile(regex);
Matchermatcher = pattern.matcher(text);
if(matcher.find()){
String group = matcher.group();
System.out.println(group);

}
//(?!)向后匹配,预测语句之后不包含括号内容,但不捕获
//语法解析:至尊后面只要不包含大宝、玉、小宝的字样,就可以匹配成功,如下案例匹配到的内容是:至尊宝,但是括号中的不包含的内容“宝”字也不会被捕获,即他的功能只是预测一下至尊后面是不是不包含某些字眼,并不会将该字眼之外的内容捕获放到匹配到的内容当中,所以如下结果打印为:至尊
String regex = "至尊(?!大宝|玉|小宝)";
String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
if(matcher.find()){
Stringgroup = matcher.group();
System.out.println(group);
}