Java学习之正则表达式快速入门
Java学习-14-韩顺平老师
Java-正则表达式入门
目录：
1. 正则表达式简介
2. 正则表达式语法
2.1 字符匹配符
2.2 选择匹配符
2.3 限定符
2.4 定位符
2.4 分组
3. 正则表达式三个常用类
4. 反向引用
5. String类使用正则表达式
正则表达式简介
基本介绍：
1.一个正则表达式，就是用某种模式去匹配字符串的一个公式。
2.其实很多语言都支持正则表达式操作，例如 Javascript、python、php等
基本使用：
public class RegExp_ {
public static void main(String[] args) {
groupReg();
normalReg();
}
// 正常匹配
public static void normalReg(){
// 用来匹配的内容
String content = "我爱写代码1998，但是我不想掉头发2001";
// 正则表达式
String regStr ="\\d{4}";
// 创建一个匹配模式，传入正则表达式
Pattern pattern = Pattern.compile(regStr);
// 创建一个匹配器,按照pattern来匹配
Matcher matcher = pattern.matcher(content);
// 循环匹配，检索，如果没有检索到就返回false
while (matcher.find()){
// 返回按照匹配规则，因为没有分组,matcher.group(0)返回匹配到的字符
System.out.println("找到 =" + matcher.group(0));
}
}
// 采用分组匹配
public static void groupReg(){
// 用来匹配的内容
String content = "我爱写代码1998，但是我不想掉头发2001";
// 正则表达式,采用分组，
// 匹配到的整段字符
// 起始位置索引存放在groups[]数组中的groups[0]中 5
// groups[1] 放的是整段字符索引的终止位置 + 1 9
// groups[2] 放的是 第1个分组匹配字符的起始位置 5
// groups[3] 放的是 第1个分组匹配字符的终止位置 7
// groups[4] 放的是 第2个分组匹配字符的起始位置 7
// groups[5] 放的是 第2个分组匹配字符的终止位置 9
String regStr ="(\\d{2})(\\d{2})";
// 创建一个匹配模式，传入正则表达式
Pattern pattern = Pattern.compile(regStr);
// 创建一个匹配器,按照pattern来匹配
Matcher matcher = pattern.matcher(content);
// 循环匹配，检索，如果没有检索到就返回false
while (matcher.find()){
// 返回按照匹配规则，因为没有分组,matcher.group(0)返回匹配到的字符
System.out.println("找到 " + matcher.group(0)); //找到 2001
// 采用分组，就可以取出分组的内容
System.out.println("找到分组1 " + matcher.group(1)); // 找到分组1 20
System.out.println("找到分组2 " + matcher.group(2)); // 找到分组1 01
}
}
}
正则表达式语法
基本介绍：
元字符从功能上大致分为一下几类：
1.字符匹配符
2.选择匹配符
3.限定符
4.定位符
5.特殊字符
6.分组组合和反向引用符
7.转义号：\ 符号，在我们使用正则表达式去检索某些特殊字符的时候，需要用到转义字符，否则检索不出结果，甚至会报错。
字符匹配符
[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"。
\d 数字字符匹配。等效于 [0-9]。
\D 非数字字符匹配。等效于 [^0-9]
\f 换页符匹配。
\n 换行符匹配。
\r 匹配一个回车符。
\s 匹配任何空白字符，包括空格、>制表>符、换页符等。
\S 匹配任何非空白字符。
\t 制表符匹配。
\v 垂直制表符匹配。
\w 匹配任何字类字符，包括下划线。
\W 与任何非单词字符匹配。
(?i)abc 表示abc都不区分大小写匹配
a(?i)ab 表示bc不区分大小写
a((?i)b)c 表示b不区分大小写
Pattern pat = Pattern.complie(regExp,Pattern.CASE.INSENSITIVE) 表示不区分大小写匹配
简单演示：
public class RegExp01 {
public static void main(String[] args) {
String content = "abc132 ABC_@";
String regStr ="";
// 返回多少字符 除\n
// String regStr = ".";
// 返回abc其中一个 [abc]
regStr = "[abc]*"; // adc
// 返回非abc [^abc] ^取反的意思
regStr = "[^abc]";
// 返回数字 \\d
// regStr = "\\d*"; // 132
// 匹配空白字符 \\s
regStr = "\\s";
// 匹配非空白字符 \\S
regStr = "\\S";
// 匹配 任何字类字符类 \\w
regStr = "\\w";
// 匹配任何非字符 \\W 例如 @ 空格
regStr = "\\W";
// 匹配adc 不区分大小写
regStr = "(?i)abc"; // 找到：abc 找到：ABC
// 在这里添加 Pattern.CASE_INSENSITIVE 也表示不区分大小写匹配
Pattern pattern = Pattern.compile(regStr,Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
System.out.println("找到：" + matcher.group(0));
}
}
}
选择匹配符
基本介绍:
在匹配某些字符串时候是选择性的，即：既可以匹配这个，也可以匹配那个，这时需要使用到匹配选择符
选择匹配符 ： |
简单演示:
public class RegExp02 {
public static void main(String[] args) {
String content = "https:123http:";
// 表示既可以匹配 https 又可以匹配http
String regStr = "https|http";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
// 输出
// 找到：https
// 找到：http
System.out.println("找到：" + matcher.group(0));
}
}
}
限定符
基本介绍：
用于限定其前面的字符和组合项连续出现多次。
常用符号如下：
. 匹配除"\r\n"之外的任何单个字符。
* 零次或多次匹配前面的字符或子表达式。
+ 一次或多次匹配前面的字符或子表达式。
? 零次或一次匹配前面的字符或子表达式。
{n} n 是非负整数。正好匹配 n 次。
{n,} n 是非负整数。至少匹配 n 次。
{n,m} m 和 n 是非负整数，其中 n <= m,匹配至少 n 次，至多 m 次。
简单演示：
public class RegExp03 {
public static void main(String[] args) {
String content = "121233aabbccdd_eeefffgg";
String regStr = null;
// 匹配一个除\r\n外的所有字符
regStr = "\\d."; // 找到 12 找到 12 找到 33
// 匹配 零次多次
regStr = "(aa)*"; // 找到 aa
// 匹配 一次或多次
regStr = "(a)+"; // 找到 aa
// 匹配 3 数字 \\d{3}
regStr = "\\d{3}"; // 找到 121 找到 233
// 匹配 4-6个字母 ,因为模式是贪婪模式，有的话，会尽量匹配6个
regStr = "[a-z]{4,6}"; // 找到 aabbcc 找到 eeefff
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
System.out.print("找到 " + matcher.group(0) + " ");
}
}
}
定位符
基本介绍：
定位符，规定要匹配的字符串出现的位置，比如在字符串的开始还是在结束的位置，这个也是相当有用的，必须掌握。
常见定位符：
^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。
$ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。
\b 匹配一个字边界，即字与空格间的位置。例如，“er\b"匹配"never"中的"er”，但不匹配"verb"中的"er"。
\B 非字边界匹配。“er\B"匹配"verb"中的"er”，但不匹配"never"中的"er"。
简单演示：
public class RegExp04 {
public static void main(String[] args) {
String content = "hello mary 123";
// 匹配以字母开头，数字结尾的字符串
String regStr = "^[a-z]+\\s\\w+\\s\\d+$";
// 下面是没有匹配结果的 ，因为 ar不在结尾 或者空格之间
regStr = "\\w+ar\\b";
// 下面
regStr = "\\w+ry\\b"; // 找到 mary
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
System.out.print("找到 " + matcher.group(0) + " ");
}
}
}
分组
基本介绍：
(pattern) 匹配 pattern 并捕获该匹配的子表达式
(?:pattern) 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。
(?=pattern) 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹>配，即不能捕获供以后使用的匹配。
(?!pattern) 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非>捕获匹配，即不能捕获供以后使用的匹配。
简单演示：
public class RegExp {
public static void main(String[] args) {
String content = "张三是帅哥 张三是法外狂徒 张三是普通市民";
// 匹配括号中内容作为一个子字符串
String regStr = "张三是([\u0391-\uffe5]+)";
// 上述也可以写成 采用 (?:pattern)
regStr = "张三是(?:帅哥|法外狂徒|普通市民)";
// 如果执行得到前面的一部分可以此阿勇 (?=pattern) ,下面只返回三个张三是
regStr = "张三是(?=帅哥|法外狂徒|普通市民)";
// 与上面的取反 ，下面不返回任何结果
regStr = "张三是(?!=帅哥|法外狂徒|普通市民)";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
System.out.println("找到：" + matcher.group(0));
}
}
}
正则表达式三个常用类
基本介绍：
java.util.regex包主要包括下面三个类，Pattern类，Matcher类和PatternSyntaxException类
Pattern类：
pattern 对象是一个正则表达式对象。Pattern类没有公共构造方法。要创建一个Pattern对象，调用其公共静态方法，它返回一个Pattern对象，该方法接受一个正则表达式作为第一个参数 例如：Pattern pattern = Pattern.compile(regStr);
Matcher类：
Matcher对象是输入字符串进行解释和匹配的引擎。与Pattern类一样，Matcher也没有公共的构造方法，需要调用Pattern对象的matcher的方法来获得一个Matcher对象。
Matcher类的常用方法：
public int start(int group）返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
public int end（返回最后匹配字符之后的偏移量)
public int end(int group)返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
public boolean lookingAt( 尝试将从区域开头开始的输入序列与该模式匹配)。
public boolean findQ尝试查找与该模式匹配的输入序列的下一个子序列。
public boolean find(int start)重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下
一个子序列。
public boolean matches()尝试将整个区域与模式匹配
简单演示：
public class RegExp02 {
public static void main(String[] args) {
String content = "http:/www.ease.center";
// 表示既可以匹配 https 又可以匹配http
String regStr = "^(https|http):/\\w*\\.\\w*\\.[a-z]*$";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
// 可以直接判断是否完全匹配， 使用matches()
boolean matches = matcher.matches();
if (matches){
System.out.println("验证成功!");
}else {
System.out.println("验证失败！");
}
while (matcher.find()){
System.out.println("找到：" + matcher.group(0));
// 与上面输出一致
System.out.println("找到：" + matcher.group(0).substring(matcher.start(),matcher.end()));
}
}
}
PatternSyntaxException类：
PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
反向引用
基本介绍：
圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以是在正则表达式内部，也可以是在正则表达式外部，内部反向引用11分组号，外部反向引用 ＄分组号。
简单演示：
public class RegExp05 {
public static void main(String[] args) {
String content = "1212123123";
// 使用 反向引用匹配重复字符串
// 每一个分组，可以使用 \\1-9 来使用前面分组
String regStr = "(\\d{2})\\1(\\d{3})\\2";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){
System.out.print("找到 " + matcher.group(0) + " ");
}
// 结巴案例
content = "我我...爱爱爱..写写..代代码码!";
// 将字符串中 ... 去除
content = content.replaceAll("\\.", "");
regStr = "(.)\\1+";
pattern = Pattern.compile(regStr);
Matcher matcher1 = pattern.matcher(content);
// 匹配到了的所有group中的字符串，全部用(.)匹配到的替换，消除了重复
content = matcher1.replaceAll("$1");
System.out.println(content);
//另种写法 直接按照模板匹配，然后直接替换
content = Pattern.compile(regStr).matcher(content).replaceAll("$1");
System.out.println(content);
}
}
String类中使用正则表达式
基本介绍：
1.public String replaceAll(String regex, String replacement)： 字符串替换
2.public String split(String regex) ：字符串拆分
3.public String matches(String regex) ：验证字符串
简单演示：
public class StringRexExp {
public static void main(String[] args) {
String content = "hello world1,i am fine";
// 替换 world1 为 mary
String mary = content.replaceAll("\\w+\\d$", "mary");
System.out.println(mary);
// 根据 空格 或者 , 分割
String[] split = content.split(" |,");
for (String s :split) {
System.out.println(s);
}
// 判断格式是否正确
String phoneNum ="13988889999";
// 验证是否以138 或者 139开头
if (phoneNum.matches("^(138|139)\\d{8}")){
System.out.println("验证通过");
}else {
System.out.println("验证失败");
}
}
}
正则表达式小结，欢迎大家交流学习！