正则表达式
regular expression
- RegExp
快速入门
正则表达式基本语法
三个常用类
- Pattern
- Magcher
- PatternSyntaxException
分组、捕获、反向引用
元字符
- 限定符
- 选择匹配符
- 分组组合和反向引用符
- 特殊字符
- 字符匹配符
- 定位符
应用实例
正则威力：
1.提取文章中所有的英文单词
2.提取文章中所有的数字
3.提取文章中所有的英文单词和数字
4、提取百度热榜标题
结论:正则表达式是处理文本的利器
体验
String content = "私有地址（Private address）属于非注册地址，专门为组织机构内部使用。\n" +
"以下列出留用的内部私有地址\n" +
"A类 10.0.0.0--10.255.255.255\n" +
"B类 172.16.0.0--172.31.255.255\n" +
"C类 192.168.0.0--192.168.255.255";
<a target=\"_blank\" title=\"印度累计确诊病例已超2000万例\" href=\"/s?wd=%E5%8Df=dd45f07d69719294a2ea6117b312f1d7_1_10_1\" class=\"c-font-medium c-color-t opr-toplist1-subtitle\">\n" +
// " 印度累计确诊病例已超2000万例\n" +
// " </a>
//提取文章中所有的英文单词
//提取文章中所有的数字
//提取文章中所有的英文单词和数字
//提取百度热榜 标题
//(1). 传统方法. 使用遍历方式，代码量大，效率不高
//(2). 正则表达式技术
//1. 先创建一个Pattern对象 ， 模式对象, 可以理解成就是一个正则表达式对象
//Pattern pattern = Pattern.compile("[a-zA-Z]+");
//Pattern pattern = Pattern.compile("[0-9]+");
//捕获 数字 | 英文
//Pattern pattern = Pattern.compile("([0-9]+)|([a-zA-Z]+)");
//匹配的是非空白字符
//匹配 title=\" (\\S*) \"。为：(\\S*) 中的是动态的。 S* 捕获内容，带了括号，需要获得 m.group(1)
//Pattern pattern = Pattern.compile("<a target=\"_blank\" title=\"(\\S*)\"");
//\\d+代表数字，可以是多个 \\. 就是.
Pattern pattern = Pattern.compile("\\d+\\.\\d+\\.\\d+\\.\\d+"); //"(\\d+.){3}\\d+"
//2. 创建一个匹配器对象
//理解： 就是 matcher 匹配器按照 pattern(模式/样式), 到 content 文本中去匹配
//找到就返回true, 否则就返回false
int no = 0;
Matcher matcher = pattern.matcher(content);
//3. 可以开始循环匹配
while (matcher.find()) {
//匹配内容，文本，放到 m.group(0)
System.out.println("找到: " + (++no) + " " +matcher.group(0));
}
//String[] split = content.split("\\d+\\.\\d+\\.\\d+\\.\\d+"); 通过正则 剪开。
pattern
n.
模式，方式；图案，花样；模范，典范；模型，底样；（布或墙纸的）样品；样式；（声音或词汇有规则排列的）模式
matcher
n.
[计] 匹配程序；制榫机；匹配器
底层实现
这四个数字要满足:第一位与第四位相同,第二位与第三位相同，比如1221 ,5775
3.请验证输入的邮件,是否符合电子邮件格式.
4、请验证输入的手机号，是否符合手机号格式
1．为了解决上述问题，Java提供了正则表达式技术，专门用于处理类似文本处，理问题
2.简单的说:正则表达式是对字符串执行模式匹配的技术。
1.一个正则表达式，就是用某种模式去匹配字符串的一个公式。很多人因
为它们看上去比较古怪而且复杂所以不敢去使用，不过，经过练习后，就觉得这些复杂的表达式写起来还是相当简单的，而且，一旦你弄懂它们，你就能把数小时辛苦而且易错的文本处理工作缩短在几分钟(甚至几秒钟)内完成
2.正则表达式不是只有java才有，实际上很多编程语
言都支持正则表达式进行字符串操作
- js，PHP 等
* 分析java的正则表达式的底层实现(重要.)
public class RegTheory {
public static void main(String[] args) {
String content = "1998年12月8日，第二代Java平台的企业版J2EE发布。1999年6月，Sun公司发布了" +
"第二代Java平台（简称为Java2）的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型" +
"版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2平台的" +
"标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2平台的企业版），应" +
"用3443于基于Java的应用服务器。Java 2平台的发布，是Java发展过程中最重要的一个" +
"里程碑，标志着Java的应用开始普及9889 ";
//目标：匹配所有四个数字
//说明
//1. \\d 表示一个任意的数字
String regStr = "(\\d\\d)(\\d\\d)";
//2. 创建模式对象[即正则表达式对象]
Pattern pattern = Pattern.compile(regStr);
//3. 创建匹配器
//说明：创建匹配器matcher， 按照 正则表达式的规则 去匹配 content字符串
Matcher matcher = pattern.matcher(content);
//4.开始匹配
/**
*
* matcher.find() 完成的任务 （考虑分组）
* 什么是分组，比如 (\d\d)(\d\d) ,正则表达式中有() 表示分组,第1个()表示第1组,第2个()表示第2组...
* 1. 根据指定的规则 ,定位满足规则的子字符串(比如(19)(98))
* 2. 找到后，将 子字符串的开始的索引记录到 matcher对象的属性 int[] groups;
* 2.1 groups[0] = 0 , 把该子字符串的结束的索引+1的值记录到 groups[1] = 4
* 2.2 记录1组()匹配到的字符串 groups[2] = 0 groups[3] = 2
* 2.3 记录2组()匹配到的字符串 groups[4] = 2 groups[5] = 4
* 2.4.如果有更多的分组.....
* 3. 同时记录oldLast 的值为 子字符串的结束的 索引+1的值即35, 即下次执行find时，就从35开始匹配
*
* matcher.group(0) 分析
*
* 源码:
* public String group(int group) {
* if (first < 0)
* throw new IllegalStateException("No match found");
* if (group < 0 || group > groupCount())
* throw new IndexOutOfBoundsException("No group " + group);
* if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
* return null;
* return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
* }
* //第一次是 0 - 4，groups[1]为4，String.subString截取是 就是不包含4
* //str.substring(0,4)，返回0到3索引，4个字符。
* 1. 根据 groups[0]=31 和 groups[1]=35 的记录的位置，从content开始截取子字符串返回
* 就是 [31,35) 包含 31 但是不包含索引为 35的位置
*
* 如果再次指向 find方法.仍然安上面分析来执行
*/
while (matcher.find()) {
//小结
//1. 如果正则表达式有() 即分组
//2. 取出匹配的字符串规则如下
//3. group(0) 表示匹配到的子字符串
//4. group(1) 表示匹配到的子字符串的第一组字串
//5. group(2) 表示匹配到的子字符串的第2组字串
//6. ... 但是分组的数不能越界.
System.out.println("找到: " + matcher.group(0));
System.out.println("第1组()匹配到的值=" + matcher.group(1));
System.out.println("第2组()匹配到的值=" + matcher.group(2));
}
}
}
语法
如果要想灵活的运用正则表达式，必须了解其中各种元字符的功能，元字符从功能上大致分为:
1．限定符
- 限定出现的次数
2.选择匹配符
- 选择 A 出现，或 B
3．分组组合和反向引用符
4、特殊字符
5.字符匹配符
6．定位符
需转义
元字符(Metacharacter)-转义号 \
\符号说明:在我们使用正则表达式去检索某些特殊字符的时候，需要用到转义符号，否则检索不到结果，甚至会报错的。
案例:用
去匹配“
a
b
c
去匹配“abc
去匹配“abc”会怎样?
用 ( 去匹配 "abc$(” 会怎样?
再次提示:
在Java的正则表达式中，两个I代表其他语言中的一个\
- / 不需要转义，想转义也可以，两个转义符 “\/”
需要用到转义符号的字符有以下:﹒*+()$/\?[] ^{}
1.字符匹配符
[ ]
可接收的字符列表
[efgh]
e、f、g、h中的任意1个字符
[^]
不接收的字符列表
[ ^abc ]
除a、 b、c之外的任意1个字符，包括数字和特殊符号
连字符
A-Z
任意单个大写字母
.
匹配除\n(换行)以外的任何字符
a..b
以a开头，b结尾，中间包括2个任意字符的长度为4的字符串
aaab、aefb、
a35b、a#*b
\\d
匹配单个数字字符，相当于[0-9]
\\d{3}(\\d)? \d出现3次。?代表 0或1，有可能有或没有
包含3个或4个数字的字符串
123、9876
\\D
匹配单个非数字字符，相当于[^0-9]
\\D(\\d)*
以单个非数字字符开头，后接任意个数字字符串
a、A342
\\w
匹配单个数字、大小写字母字符和下划线，相当于[O-9a-zA-Z_]，除了下划线之外的符号，不匹配
\\d{3}\\w{4}
以3个数字字符开头的长度为7的数字字母字符串
234abcd
12345Pe
\\W
匹配单个非数字、大小写字母字符，相当于[^0-9a-zA-Z_]
\\W+\\d{2} \\W+代表1到多。前面非数字字母是1个或多个。
以至少1个非数字字母字符开头，2个数字字符结尾的字符串
#29, #?@10
举例说明
String content = "abc$(a.bc(123( )";
//匹配( => \\(
//匹配. => \\.
//String regStr = "\\."; 只写一个.匹配所有的字符。
//String regStr = "\\d\\d\\d";
String regStr = "\\d{3}";//出现3次
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
(?i)abc 表示abc都不区分大小写
a(?i)bc 表示bc不区分大小写
a((?i)b)c 表示只有b不区分大小写
Pattern pattern = Pattern.compile(regStr, Pattern.CASE_INSENSITIVE);
insensitive
英
/ɪnˈsensətɪv/
adj.
（对他人的感受）未意识到的，漠不关心的；身体无感觉的，麻木的；不敏感的，反应迟钝的
\\s匹配任何空白字符(空格,制表符等)
\\S 匹配任何非空白字符，和\\s刚好相反
String content = "a11c8abc _ABCy @_#";
//String regStr = "[a-z]";//匹配 a-z之间任意一个字符
//String regStr = "[A-Z]";//匹配 A-Z之间任意一个字符
//String regStr = "abc";//匹配 abc 字符串[默认区分大小写]
//String regStr = "(?i)abc";//匹配 abc 字符串[不区分大小写]
//String regStr = "[0-9]";//匹配 0-9 之间任意一个字符
//String regStr = "[^a-z]";//匹配 不在 a-z之间任意一个字符。[^a-z]{2} 连续2个不是a-z的。如：11 AB _#
//String regStr = "[^0-9]";//匹配 不在 0-9之间任意一个字符
//String regStr = "[abcd]";//匹配 在 abcd中任意一个字符
//String regStr = "\\D";//匹配 不在 0-9的任意一个字符
String regStr = "\\w";//匹配 大小写英文字母, 数字，下划线
//String regStr = "\\W";//匹配 等价于 [^a-zA-Z0-9_]
//\\s 匹配任何空白字符(空格,制表符等)
//String regStr = "\\s";
//\\S 匹配任何非空白字符 ,和\\s刚好相反
//String regStr = "\\S";
//. 匹配出 \n 之外的所有字符,如果要匹配.本身则需要使用 \\.
//String regStr = ".";
//说明
//1. 当创建Pattern对象时，指定 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));
}
2.选择匹配符
元字符-选择匹配符
在匹配某个字符串的时候是选择性的，即:既可以匹配这个，又可以匹配那个，这时你需要用到选择匹配符号|
|
匹配“|”之前或之后的表达式
ab|cd
ab或者cd
String content = "hanshunping 韩 寒冷";
String regStr = "han|韩|寒";
3.限定符
用于指定其前面的字符和组合项连续出现多少次
*
指定字符重复0次或n次(无要求)
(abc)*
仅包含任意个abc的字符串，等效于\w*
abc、abcabcabc
+
指定字符重复1次或n次(至少一次)
m+(abc)*
以至少1个m开头，后接任意个abc的字符串
m,mabc,mabcabc
?
指定字符重复0次或1次(最多1次)
m+abc? 没有括起来，就是跟c关联的。（abc）?这样才是一个整体
至少1个m开头，后接ab或abc的字符
mab,mabc,mmmab,mmabc
{n}
只能输入n个字符
[abcd]{3}
由abcd中字母组成的任意长度为3的字
abc,dbc,adc
{n,}指定至少n个匹配
[abcd]{3,}
由abcd中字母组成的任意长度不小于3的字符串
aab,dbc,aaabdc
{n,m}
指定至少n个但不多于m个匹配
[abcd]{3,5}
由abcd中字母组成的任意长度不小于3,不大于5的字符串
abc,abcd,aaaaa，bcdab
举例说明
public static void main(String[] args) {
String content = "a211111aaaaaahello";
//a{3},1{4},\\d{2}
//String regStr = "a{3}";// 表示匹配 aaa
//String regStr = "1{4}";// 表示匹配 1111。如果 1111111aa，匹配后还剩111，匹配不到了。
//String regStr = "\\d{2}";// 表示匹配 两位的任意数字字符
//a{3,4},1{4,5},\\d{2,5}
//细节：java匹配默认贪婪匹配，即尽可能匹配多的。如果是6个a，也是匹配1次4个a，剩下的不匹配
String regStr = "a{3,4}"; //表示匹配 aaa 或者 aaaa
//String regStr = "1{4,5}"; //表示匹配 1111 或者 11111
//String regStr = "\\d{2,5}"; //匹配2位数或者3,4,5
//1+
//String regStr = "1+"; //匹配一个1或者多个1
//String regStr = "\\d+"; //匹配一个数字或者多个数字
//1*
//String regStr = "1*"; //匹配0个1或者多个1
//演示?的使用, 遵守贪婪匹配
//String regStr = "a1?"; //匹配 a 或者 a1
Pattern pattern = Pattern.compile(regStr/*, Pattern.CASE_INSENSITIVE*/);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
}
4.定位符
定位符，规定要匹配的李符串出现的位置，比如在字符串的开始还是在结束的位置，这个也是相当有用的，必须掌握
^
指定起始字符
^[0-9]+[a-z]* +代表1到多。*是0到多
以至少1个数字开头，后接任意个小写字母的字符串
123,6aa,555edf
"[^a-z]";//匹配 不在 a-z之间任意一个字符
$
指定结束字符
^[0-9]\\-[a-z]+$
以1个数字开头后接连字符“-”，并以至少1个小写字母结尾的字符串
1-a
\\b
匹配目标字符串的边界
han\\b
文里说的字符串的边界指的是子串间有空格，或者是自标字符串的结束位置
hanshunping 匹配不到
sphan nnhan 这两匹配，也可能是 空格间隔，也认为是边界。
\B
匹配目标字符串的非边界
han\\B
和\b的含义刚刚相反
hanshunping 这个匹配
sphan nnhan
举例说明
String content = "hanshunping sphan nnhan";
//String content = "123-abc";
//以至少1个数字开头，后接任意个小写字母的字符串
//String regStr = "^[0-9]+[a-z]*";
//以至少1个数字开头, 必须以至少一个小写字母结束
//String regStr = "^[0-9]+\\-[a-z]+$";
//表示匹配边界的han[这里的边界是指：被匹配的字符串最后,
// 也可以是空格的子字符串的后面]
//String regStr = "han\\b";
//和\\b的含义刚刚相反
String regStr = "han\\B";
分组
命名和非命名
(pattern)
非命名捕获。捕获匹配的子字符串。编号为零的第一个捕获是由整个正则表达式模式匹配的文本，其它捕获结果则根据左括号的顺序从1开始自动编号。
（？ pattern)
命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中。用于name的字符串不能包含任何标点符号，并且不能以数字开头。可以使用单引号替代尖括号，例如(?‘name’)
String content = "hanshunping s7789 nn1189han";
//下面就是非命名分组
//说明
// 1. matcher.group(0) 得到匹配到的字符串
// 2. matcher.group(1) 得到匹配到的字符串的第1个分组内容
// 3. matcher.group(2) 得到匹配到的字符串的第2个分组内容
//String regStr = "(\\d\\d)(\\d\\d)";//匹配4个数字的字符串
//命名分组： 即可以给分组取名
String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";//匹配4个数字的字符串
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到=" + matcher.group(0));
System.out.println("第1个分组内容=" + matcher.group(1));
System.out.println("第1个分组内容[通过组名]=" + matcher.group("g1"));
System.out.println("第2个分组内容=" + matcher.group(2));
System.out.println("第2个分组内容[通过组名]=" + matcher.group("g2"));
}
非捕获
(?:pattern)
匹配pattern但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符(|)组合模式部件的情况很有用。例如，"industr(?:y|ies)是比"industry|industries'更经济的表达式。
(?=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"。
String content = "hello韩顺平教育 jack韩顺平老师 韩顺平同学hello韩顺平学生";
// 找到 韩顺平教育 、韩顺平老师、韩顺平同学 子字符串
//String regStr = "韩顺平教育|韩顺平老师|韩顺平同学";
//上面的写法可以等价非捕获分组, 注意：不能 matcher.group(1)
//String regStr = "韩顺平(?:教育|老师|同学)";
//找到 韩顺平 这个关键字,但是要求只是查找韩顺平教育和 韩顺平老师 中包含有的韩顺平
//下面也是非捕获分组，不能使用 matcher.group(1)
//String regStr = "韩顺平(?=教育|老师)";//matcher.group(0) 获取的是2次 韩顺平。不含：教育 老师字
//找到 韩顺平 这个关键字,但是要求只是查找 不是 (韩顺平教育 和 韩顺平老师) 中包含有的韩顺平
//下面也是非捕获分组，不能使用 matcher.group(1)
String regStr = "韩顺平(?!教育|老师)";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到: " + matcher.group(0));
}
非贪婪 其他常用元字符
? 当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。
\num 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
\s 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
String content = "hello111111 ok";
//String regStr = "\\d+"; //默认是贪婪匹配
String regStr = "\\d+?"; //非贪婪匹配。会匹配成功6次，6个1
String regStr="(.)\\1";//ll 11重复的会被匹配到。反向引用
正则实例
手机 QQ 邮编 汉字
String content = "13588889999";
// 汉字
//String regStr = "^[\u0391-\uffe5]+$";
// 邮政编码
// 要求：1.是1-9开头的一个六位数. 比如：123890
// 2.
// 3.
//String regStr = "^[1-9]\\d{5}$";
// QQ号码
// 要求: 是1-9开头的一个(5位数-10位数) 比如: 12389 , 1345687 , 187698765
//String regStr = "^[1-9]\\d{4,9}$";
// 手机号码
// 要求: 必须以13,14,15,18 开头的11位数 , 比如 13588889999
String regStr = "^1[3|4|5|8]\\d{9}$"; //换成()也可以
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
if(matcher.find()) {
System.out.println("满足格式");
} else {
System.out.println("不满足格式");
}
网址和整体匹配
String regStr = ".";// 匹配除了\n的所有字符。如果想匹配. 需要[.] 等价 \\.
//String content = "https://www.bilibili.com/video/BV1fh411y7R8?from=search&seid=1831060912083761326";
String content = "http://edu.3dsmax.tech/yg/bilibili/my6652/pc/qg/05-51/index.html#201211-1?track_id=jMc0jn-hm-yHrNfVad37rKU";
String reg="^((https?)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=#]*)?$"
/**
* 思路
* 1. 先确定 url 的开始部分 https:// | http://
* 2.然后通过 ([\w-]+\.)+[\w-]+ 匹配 www.bilibili.com
* 3. /video/BV1fh411y7R8?from=sear 匹配(\/[\w-?=&/%.#]*)?
*/
//?是0或1次。\w包含了下划线，又加了 中划线。 +代表1次或n次。*代表0次或多次。
//^((http|https)://)? http开头，可有可没有
//([\w-]+\.)+ 字符数字或- 1次或多次。用于匹配：www.bilibili.
// com/video/BV1fh4 使用：[\w-]+ 字符字母中划线出现1次或多次。
//(\/[\w-?=&/%.#]*)?$ 后面跟 / 字符 各种特殊符号。出现 0次或多次。 这个分组：出现0次或1次。
String regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";//注意：[. ? *]表示匹配就是.本身
//前面的优化为：^(https?://)? s出现0次或1次
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
if(matcher.find()) {
System.out.println("满足格式");
} else {
System.out.println("不满足格式");
}
//这里如果使用Pattern的matches 整体匹配 比较简洁
System.out.println(Pattern.matches(regStr, content));//
String content = "hello abc hello, 韩顺平教育";
//String regStr = "hello"; //整体匹配会失败。
String regStr = "hello.*"; //整体匹配成功
boolean matches = Pattern.matches(regStr, content);
System.out.println("整体匹配= " + matches);
常用类
java.util.regex包主要包括以下三个类
Pattern类、
Matcher类和
PatternSyntaxException
Pattern类
pattern对象是一个正则表达式对象。Pattern类没有公共构造方法。要创建一个 Pattern对象，调用其公共静态方法，它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数，
比如:Pattern r= Pattern.compile(pattern);
Matcher 类
Matcher 对象是对输入字符串进行解释和匹配的引擎。与Pattern类一样,Matcher也没有公共构造方法。你需要调用Pattern对象的 matcher方法来获得一个 Matcher对象
Matcher matcher = pattern.matcher(content);
PatternSyntaxException
PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错
Matcher
public int start()返回以前匹配的初始索引。
public int start(int group)返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
public int end()返回最后匹瓯字符之后的偏移量。
public int end(int group)返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量
public boolean lookingAt()尝试将从区域开头开始的输入序列与该模式匹配。
public boolean find()尝试查找与该模式匹配的输入序列的下一个子序列。
public boolean find(int start)重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的一个子序列。
public boolean matches()尝试将整个区域与模式匹配。
public String replaceAll(String replacement)替换模式与给定替换字符串相匹配的输入序列的每个子序列。
实战 start 和 end方法
String content = "hello edu jack hspedutom hello smith hello hspedu hspedu";
String regStr = "hello";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("=================");
System.out.println(matcher.start());
System.out.println(matcher.end());//就是group数组的 1索引的值，记录了匹配的结束索引+1
System.out.println("找到: " + content.substring(matcher.start(), matcher.end()));//不包含结束，直接截取到。
}
//整体匹配方法，常用于，去校验某个字符串是否满足某个规则
System.out.println("整体匹配=" + matcher.matches());
//完成如果content 有 hspedu 替换成 韩顺平教育
regStr = "hspedu";
pattern = Pattern.compile(regStr);
matcher = pattern.matcher(content);
//注意：返回的字符串才是替换后的字符串 原来的 content 不变化
String newContent = matcher.replaceAll("韩顺平教育");
System.out.println("newContent=" + newContent);
System.out.println("content=" + content);
分组 捕获 反向引用
查出：1221 4334，这样的
要解决前面的问题,我们需要了解正则表达式的几个概念:
1.分组
我们可以用圆括号组成一个比较复杂的匹配模式，那么一个圆括号的部分我们可以看作是一个子表达式/一个分组。
2.捕获
把正则表达式中子表达式/分组匹配的内容，保存到内存中以数字编号或显式命名的组里,方便后面引用，从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。组0代表的是整个正则式
3.反向引用
圆括号的内容被捕获后，可以在这个括号后被使用，从而写出一个比较实用的匹配模式，这个我们称为反向引用，这种引用既可以是在正则表达式内部，也可以是在正则表达式外部，内部反向引用\\分组号，外部反向引用$分组号
实战 相同的数
String content = "h1234el9876lo33333 j12324-333999111a1551ck14 tom11 jack22 yyy12345 xxx";
//要匹配两个连续的相同数字 : (\\d)\\1
//String regStr = "(\\d)\\1";
//要匹配五个连续的相同数字： (\\d)\\1{4}
//String regStr = "(\\d)\\1{4}";
//要匹配个位与千位相同，十位与百位相同的数 5225 , 1551 (\\d)(\\d)\\2\\1
//String regStr = "(\\d)(\\d)\\2\\1";
/**
* 请在字符串中检索商品编号,形式如:12321-333999111 这样的号码,
* 要求满足前面是一个五位数,然后一个-号,然后是一个九位数,连续的每三位要相同
*/
String regStr = "\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()) {
System.out.println("找到 " + matcher.group(0));
}
实战2 去重
String content = "我....我要....学学学学....编程java!";
//1. 去掉所有的.
Pattern pattern = Pattern.compile("\\.");
Matcher matcher = pattern.matcher(content);
content = matcher.replaceAll("");
// System.out.println("content=" + content);
//2. 去掉重复的字 我我要学学学学编程java!
// 思路
//(1) 使用 (.)\\1+
//(2) 使用 反向引用$1 来替换匹配到的内容
// 注意：因为正则表达式变化，所以需要重置 matcher
// pattern = Pattern.compile("(.)\\1+");//分组的捕获内容记录到$1
// matcher = pattern.matcher(content);
// while (matcher.find()) {
// System.out.println("找到=" + matcher.group(0));
// }
//
// //使用 反向引用$1 来替换匹配到的内容。我我 用我替换。 学学学学 用 学替换。
// content = matcher.replaceAll("$1");
// System.out.println("content=" + content);
//3. 使用一条语句 去掉重复的字 我我要学学学学编程java!
content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
System.out.println("content=" + content);
String中使用正则
String类
public String replaceAll(String regex,String replacement)
public boolean matches(String rege)
实战 手机号
String content = "2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，几周后其" +
"获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，J2EE1.3发" +
"布。" +
"2002年2月26日，J2SE1.4发布。自此Java的计算能力有了大幅提升";
//使用正则表达式方式，将 JDK1.3 和 JDK1.4 替换成JDK
content = content.replaceAll("JDK1\\.3|JDK1\\.4", "JDK");
System.out.println(content);
//要求 验证一个 手机号， 要求必须是以138 139 开头的
content = "13888889999";
String regStr = "^1[3|4|5|8]\\d{9}$";
System.out.println(content.matches(regStr));
//"^13(8|9)\\d{8}$"
if (content.matches("1(38|39)\\d{8}")) {
//1[38|39]\d{8} 这种错误，代表：10位，3重复，后8位数字。1开头在选38|9一个。 如：1|88888999
System.out.println("验证成功");
} else {
System.out.println("验证失败");
}
//要求按照 # 或者 - 或者 ~ 或者 数字 来分割
System.out.println("===================");
content = "hello#abc-jack12smith~北京";
String[] split = content.split("#|-|~|\\d+");
for (String s : split) {
System.out.println(s);
}
练习
邮箱
//规定电子邮件规则为
//只能有一个@
//@前面是用户名,可以是a-z A-Z 0-9 _-字符
//@后面是域名,并且域名只能是英文字母， 比如 sohu.com 或者 tsinghua.org.cn
// 写出对应的正则表达式, 验证输入的字符串是否为满足规则
String content = "hsp@tsinghua.org.cn";
//[\w-]+
//@([a-zA-Z]+\.)+ 可以出现1或多次。 点记得做转义
//[a-zA-Z]+ 匹配最终的字符。 如 com
String regStr = "^[\\w-]+@([a-zA-Z]+\\.)+[a-zA-Z]+$";
//老师说明
//1. String 的 matches 是整体匹配
//2. 看看这个matches 底层
/**
* String 的 matches
* public boolean matches(String regex) {
* return Pattern.matches(regex, this);
* }
*
* Pattern
* public static boolean matches(String regex, CharSequence input) {
* Pattern p = Pattern.compile(regex);
* Matcher m = p.matcher(input);
* return m.matches();
* }
*
* Mather类 match
* Attempts to match the entire region against the pattern
* public boolean matches() {
* return match(from, ENDANCHOR);
* }
*/
if (content.matches(regStr)) {
System.out.println("匹配成功");
} else {
System.out.println("匹配失败");
}
整数或小数
//要求验证是不是整数或者小数
//提示： 这个题要考虑正数和负数
//比如： 123 -345 34.89 -87.9 -0.01 0.45 等
/**
* 老师的思路
* 1. 先写出简单的正则表达式
* 2. 在逐步的完善[根据各种情况来完善]
*/
String content = "-0.89"; //
String regStr = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";
if(content.matches(regStr)) {
System.out.println("匹配成功 是整数或者小数");
} else {
System.out.println("匹配失败");
}
域名解析
String content = "http://www.sohu.com:8080/abc/xxx/yyy/inde@#$%x.htm";
//因为正则表达式是根据要求来编写的，所以，如果需求需要的话，可以改进.
String regStr= "^([a-zA-Z]+)://([a-zA-Z.]+):(\\d+)[\\w-/]*([\\w.@#$%]+)$";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);
if(matcher.matches()) {//整体匹配, 如果匹配成功，可以通过group(x), 获取对应分组的内容
System.out.println("整体匹配=" + matcher.group(0));
System.out.println("协议: " + matcher.group(1));
System.out.println("域名: " + matcher.group(2));
System.out.println("端口: " + matcher.group(3));
System.out.println("文件: " + matcher.group(4));
} else {
System.out.println("没有匹配成功");
}
1570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
