java正则表达式详解

正则表达式：

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

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

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

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()返回本次查找到的内容

注意，当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 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,}	n 是非负整数。至少匹配 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 ="[email protected]";
                  
 
                   //验证网址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);     
         }