java正则表达式

一、简介：

1、正则表达式（Regular Expression）：用来描述一个大的字符串里面所包含的N个小的含有共同特征的一个字符串。

例如：在帖子里搜索所有包含“植物”隐藏掉，则包含了“植物”的字符串就是正则表达式

2、java为正则表达式，提供了API。包装在java.util.regex包，用于匹配格式的验证。java.util.regex包中含有以下2个类：

1）Pattern类：用来保存编译过的正则表达式，没有public的构造方法，不能直接new。需要使用静态方法Compile来创建该类的实例。

2）Matcher类：应用正则表达式，匹配目标字符串，也没有public的构造方法，不能直接new。需要使用Pattern类的静态方法matcher来创建该类的实例。

3）编写正则表达式步骤，参考代码：

//第一步：确定正则表达式
Pattern p1=Pattern.compile("正则表达式");//参数中写正则表达式，相当于搜索条件
//第二步：确定目标字符串
Matcher m1=p1.matcher("目标字符串");//参数中写目标字符串
//执行匹配
System.out.println(m1.matches());//判断是否匹配，找到返回true

这里使用matcher(）方法：用于匹配整个字符串

4）find( )方法：匹配目标字符串的子字符串，匹配过之后不再匹配

public static void main(String[] args) {
Pattern p1=Pattern.compile("[abc][a-zA-Z]oo");//参数中写正则表达式，相当于搜索条件
Matcher m1=p1.matcher("sazoosbdooscCoo");//参数中写目标字符串，匹配整个字符串，返回false
boolean isFind=false;
while(m1.find()){//匹配子字符串
isFind=true;
System.out.println(
"匹配到的字符串："+m1.group()+
"，开始于："+m1.start()+
"，结束于："+m1.end());
}
if(!isFind){
System.out.println("没有匹配到任何字符串");
}
}

运行结果：

匹配到的字符串：azoo，开始于：1，结束于：5
匹配到的字符串：bdoo，开始于：6，结束于：10
匹配到的字符串：cCoo，开始于：11，结束于：15

匹配字符的路径介绍：



二、正则表达式语法

1、字符串常量：正则表达式是一个常量，匹配常量是否在目标字符串中存在

2、字符串类：需要编译，分为以下几种：

1）[abc]        匹配一个a或者一个b或者一个c，一个中括号代表一位字符

2）[^abc]       匹配取反：不是a且不是b且不是c

3）[a-z]        匹配范围a-z所有的小写字符

4）[a-zA-Z]     并集：匹配所有的大写字母或者小写字母

5）[a-d[m-p]]、[a-dm-p] 匹配a-d和m-p的所有字符，包括边界

6）[a-d&&[def]] 交集：匹配相交的d

7）[a-z&&[^def]]交集：匹配a-z中非def的小写字母

8）[0-9] 匹配所有的数字

3、预定义字符串类：不需要编译，效率快些。分为以下几种：

1）.    代表一位任意字符

2）\d  所有的数字[0-9]，单独\：java的保留符号，转义字符，需要使用这个时加个\
3）\D 一位非数字的任意字符，相当于[^0-9]
4）\s 一位空白字符：tab键，空格，换行，不常用
5）\S 一位非空白字符：tab键，空格，换行，不常用
6）\w 代表一位键盘字符，相当于字母与数字的集合[a-zA-Z0-9]
7）W  代表一位非字母非数字的字符，相当于字母与数字的集合[^\w]

参考代码：

public class PredefindStringClasses {
public static void main(String[] args) {
//第一步：确定正则表达式
Pattern p1=Pattern.compile(".\\d\\D\\s\\S\\w\\W");//参数中写正则表达式，相当于搜索条件
//第二步：确定目标字符串
Matcher m1=p1.matcher("@1h D2!12* ^c!0hy Cv@3");//参数中写目标字符串，匹配整个字符串，返回false

boolean isFind=false;
//执行匹配，从目标字符串中匹配所有符合条件的正则表达式
while(m1.find()){//匹配子字符串
isFind=true;
System.out.println(
"匹配到的字符串："+m1.group()+
"，开始于："+m1.start()+
"，结束于："+m1.end());
}
if(!isFind){
System.out.println("没有匹配到任何字符串");
}
}
}

运行后结果：

匹配到的字符串：@1h D2!，开始于：0，结束于：7
匹配到的字符串：12* ^c!，开始于：7，结束于：14

4、量词：记录字符串出现的次数，只修饰挨着这一位字符ba+ +修饰a

1）？ a?   代表a出现0次或1次，一次最多匹配一个a

2）* a*      代表a出现0次或多次，与a?的区别，一次可以匹配n个a(a连续)

3）+ a+     a出现1次或者多次  一次匹配多个a(a连续)

4）{m} a{m} a出现m次 a{3}匹配aaa(a连续)

5）{m,n}    出现m次到n次

6）{m,}     至少出现m次

7）{,n}     最多出现n次

8）分组  (ba)+ 一次匹配多个ba ba出现一次或多次(ba连续)

9）[ba]+   一次匹配多个连续的a或b

参考代码：

public static void main(String[] args) {
//第一步：确定正则表达式
Pattern p1=Pattern.compile("a?");//参数中写正则表达式，相当于搜索条件
Pattern p2=Pattern.compile("ba+");
Pattern p3=Pattern.compile("(ba)+");
Pattern p4=Pattern.compile("[ba]+");
Pattern p5=Pattern.compile("[0-9]{17}\\w");//身份证的正则表达式
//第二步：确定目标字符串
Matcher m1=p1.matcher("");//Zero-length Matches参数中写目标字符串，匹配整个字符串，返回false
Matcher m2=p1.matcher("a");
Matcher m3=p1.matcher("c");
Matcher m4=p2.matcher("aaababaabaaa");
Matcher m5=p3.matcher("aaababaabaaa");
Matcher m6=p4.matcher("bacabdab");
//执行匹配，从目标字符串中匹配所有符合条件的正则表达式
while(m1.find()){//匹配子字符串
System.out.println("匹配到的字符串："+m1.group()+"，开始于："+m1.start()+"，结束于："+m1.end());
}
while(m2.find()){//匹配子字符串
System.out.println("匹配到的字符串："+m2.group()+"，开始于："+m2.start()+"，结束于："+m2.end());
}
while(m3.find()){//匹配子字符串
System.out.println("匹配到的字符串："+m3.group()+"，开始于："+m3.start()+ "，结束于："+m3.end());
}
while(m4.find()){//匹配子字符串
System.out.println("匹配到的字符串："+m4.group()+"，开始于："+m4.start()+ "，结束于："+m4.end());
}
while(m5.find()){//匹配子字符串
System.out.println("匹配到的字符串："+m5.group()+"，开始于："+m5.start()+ "，结束于："+m5.end());
}
while(m6.find()){//匹配子字符串
System.out.println("匹配到的字符串："+m6.group()+"，开始于："+m6.start()+ "，结束于："+m6.end());
}
}运行结果：
匹配到的字符串：，开始于：0，结束于：0
匹配到的字符串：a，开始于：0，结束于：1
匹配到的字符串：，开始于：1，结束于：1
匹配到的字符串：，开始于：0，结束于：0
匹配到的字符串：，开始于：1，结束于：1
匹配到的字符串：ba，开始于：3，结束于：5
匹配到的字符串：baa，开始于：5，结束于：8
匹配到的字符串：baaa，开始于：8，结束于：12
匹配到的字符串：baba，开始于：3，结束于：7
匹配到的字符串：ba，开始于：8，结束于：10
匹配到的字符串：ba，开始于：0，结束于：2
匹配到的字符串：ab，开始于：3，结束于：5
匹配到的字符串：ab，开始于：6，结束于：8
三、正则表达式的3种匹配方式
1、Greedy 贪婪的，默认的，写法：a*、a?、a+等

2、Reluctant 懒惰的，写法：a*？、a?？、a+?等

3、Possessive 侵占的，写法：a*+、a?+、a++等

参考代码：

public class MathWays {
public static void main(String[] args) {
MathWays m1=new MathWays();
MathWays m2=new MathWays();
MathWays m3=new MathWays();
//贪婪，其中.*代表foo前面可以是任意字符。
//一次性把目标读入后，从最后一个字符开始，一个个字符进行匹配，匹配到目标后，继续匹配，直到目标字符串匹配完成
m1.test(".*foo");//匹配到一个
//懒惰：从前往后匹配，一次匹配一个，直到匹配到目标字符时，继续往下匹配
m2.test(".*?foo");//匹配到2个
//侵占：一次性读取完毕，进行整个匹配
m3.test(".*+foo");//匹配不到内容
}
public void test(String reg){
//第一步：确定正则表达式
Pattern p=Pattern.compile(reg);
//第二步：确定目标字符串
Matcher m=p.matcher("sfoossssssfoo");
//执行匹配，从目标字符串中匹配所有符合条件的正则表达式
boolean isFind=false;
while(m.find()){//匹配子字符串
isFind=true;
System.out.println(reg+"：匹配到的字符串："+m.group()+"，开始于："+m.start()+"，结束于："+m.end());
}
if(!isFind){
System.out.println(reg+"：没有匹配到任何字符串");
}
}
}
运行后结果：

.*foo：匹配到的字符串：sfoossssssfoo，开始于：0，结束于：13
.*?foo：匹配到的字符串：sfoo，开始于：0，结束于：4
.*?foo：匹配到的字符串：ssssssfoo，开始于：4，结束于：13
.*+foo：没有匹配到任何字符串