正则表达式：
正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。
正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。
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 ="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);
}