正则表达式学习总结
- 引言
用户消息，一般都有固定格式，利用正则匹配到想要的字段。
如用户字段：
============================================================================================\n" +
// "IP 地址 - 子网掩码 - 唯一的 ID - 租用过期 - 种类\n" +
// "==================================================================================\n" +
// "\n" +
// "192.100.100.209 - 255.255.255.0 - 56-50-4d-98-00-02-00-2021/3/6 15:35:39 -D\n" +
// "192.100.100.210 - 255.255.255.0 - 56-50-4d-98-00-02-00-2021/3/6 15:38:16 -D\n" +
// "192.100.100.211 - 255.255.255.0 - 69-73-63-6f-20-53-79-2021/3/12 10:39:47 -D\n" +
// "192.100.100.212 - 255.255.255.0 - 00-50-56-83-57-e3 -2021/3/12 10:42:40 -D\n" +
// "192.100.100.213 - 255.255.255.0 - 00-50-56-a6-75-80 -2021/3/12 10:43:07 -D\n" +
// "\n" +
// "作用域 : 192.100.100.0 中的客户端数目(版本 4): 19。";
可以利用正则得到用户ip,mask，mac,rent_time，type 等等信息
正则介绍以及测试Pattern 说明
public static void main(String[] args) {
Pattern pattern = Pattern.compile("\\?|\\*");
for(String s:pattern.split("aaaa?bbbb*cccc*dddd?2222",3)){
System.out.print(s+" ");
}
System.out.println();
}
测试结果：aaaa bbbb cccc*dddd?2222
说 明：正则为？ 或者为* ，
按照正则将字符串拆分
3，代表，将字符串拆为三段，如果是2 结果为 aaaa bbbb*cccc*dddd?2222
public static void main(String[] args) {
Pattern pattern = Pattern.compile("\\d+");
for(String s:pattern.split("aaa2bbb2222ccc3333ddd333fff",-1)){
System.out.print(s+" ");
}
System.out.println();
}
测试结果：
aaa bbb ccc ddd fff
说 明： 按照最大匹配结果对字符串进行拆分。
- 对Matcher的测试以及说明
/**
Pattern 只有，可以有三种不同的匹配操作：
1. matches () 尝试将整个序列与该模式匹配
2. lookingAt 尝试将输入的序列从开头与该模式进行匹配
3. find() 扫描输入序列查找与该模式匹配的下一个序列
3.1 group() 返回匹配的子字符串
**/
public static void main(String[] args) {
Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher("33333 dousil 444444 gaomimi 555555");
System.out.println(matcher.matches());
System.out.println(matcher.lookingAt());
System.out.println(matcher.group());
while(matcher.find()){
System.out.println(matcher.group());
}
}
测试结果：
false
true
33333
444444
555555
结果分析：
false： 整个字符串匹配不成功
true: 从头开始匹配成功，并输出33333
接着从dousil开始接着往后匹配 注意：灰色部分，导致while循环内的数据不是从3333开始。
- Matcher 的group的测试
public static void main(String[] args) {
Pattern pattern = Pattern.compile("(\\d+)([a-z]{5})(444)");
Matcher matcher = pattern.matcher("33333sssss444444");
matcher.find();
System.out.println(matcher.groupCount());
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));
}
测试结果:
3
33333sssss444
33333
sssss
444
Exception in thread "main" java.lang.IndexOutOfBoundsException: No group 4
at java.util.regex.Matcher.group(Matcher.java:538)
at com.uxsino.simo.collector.simulate.ValueMapUtil.main(ValueMapUtil.java:58)
Process finished with exit code
结果说明：
一个括号是一个 组。+ 为贪婪匹配，尽可能的多的去匹配
- 示例：
public static void main(String[] args) {
// 测试是否为合法的身份证号码
String[]id_cards = { "130681198712092019","13068119871209201x","13068119871209201","123456789012345",
"12345678901234x","1234567890123"};
// 测试是否为合法身份证的正则表达式
Patternpattern = Pattern.compile("(\\d{17}[0-9a-zA-Z]|\\d{14}[0-9a-zA-Z])");
// 用于提取出生日字符串的正则表达式
Patternpattern1 = Pattern.compile("\\d{6}(\\d{8}).*");
// 用于将生日字符串分解为年月日的正则表达式
Patternpattern2 = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");
Matchermatcher = pattern.matcher("");
for (int i = 0; i < id_cards.length; i++) {
matcher.reset(id_cards[i]);
System.out.println(id_cards[i] + " is id cards：" + matcher.matches());
// 如果它是一个合法的身份证号，提取出出生的年月日
if (matcher.matches()) {
Matchermatcher1 = pattern1.matcher(id_cards[i]);
matcher1.lookingAt();
Stringbirthday = matcher1.group(1);
Matchermatcher2 = pattern2.matcher(birthday);
if (matcher2.find()) {
System.out.println("它对应的出生年月日为：" + matcher2.group(1) + "年" + matcher2.group(2) + "月"
+matcher2.group(3) + "日");
}
}
System.out.println();
}
}
}
测试结果：
————————————————
版权声明：本文为CSDN博主「知行流浪」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zengxiantao1994/article/details/77803960/
- 过滤掉开头和结尾的方法如下所示
protected String getTable(String buf) {
if (prefixPattern != null) {
Pattern pattern = Pattern.compile(prefixPattern, Pattern.DOTALL);
Matcher m = pattern.matcher(buf);
if (m != null) {
buf = m.replaceFirst("");
}
}
if (surffixPattern != null) {
Pattern pattern = Pattern.compile(surffixPattern, Pattern.DOTALL);
Matcher m = pattern.matcher(buf);
if (m != null) {
buf = m.replaceFirst("");
}
}
return buf;
}
- c常用到的正则匹配
1 匹配首尾空格的正则表达式：(^\s*)|(\s*$)
2 整数或者小数：^[0-9]+\.{0,1}[0-9]{0,2}$
3 只能输入数字："^[0-9]*$"。
4 只能输入n位的数字："^\d{n}$"。
5 只能输入至少n位的数字："^\d{n,}$"。
6 只能输入m~n位的数字：。"^\d{m,n}$"
7 只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。
8 只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。
9 只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。
10 只能输入非零的正整数："^\+?[1-9][0-9]*$"。
11 只能输入非零的负整数："^\-[1-9][]0-9"*$。
12 只能输入长度为3的字符："^.{3}$"。
13 只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。
14 只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。
15 只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。
16 只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。
17 只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。
18 验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。
19 验证是否含有^%&',;=?$\"等字符："[^%&',;=?$\x22]+"。
20 只能输入汉字："^[\u4e00-\u9fa5]{0,}$"
21 验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。
22 验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。
23 验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。
24 验证身份证号（15位或18位数字）："^\d{15}|\d{18}$"。
25 验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。
26 验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～"31"。
27 匹配中文字符的正则表达式： [\u4e00-\u9fa5]
28 匹配双字节字符(包括汉字在内)：[^\x00-\xff]
29 应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
30 String.prototype.len=function(){return this.replace(/[^\x00-\xff]/g,"aa").length;}
31 匹配空行的正则表达式：\n[\s| ]*\r
32 匹配html标签的正则表达式：<(.*)>(.*)<\/(.*)>|<(.*)\/>
————————————————
版权声明：本文为CSDN博主「千山暮雪CN」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_36927265/article/details/87864026
- 测试正则表达式的各种模型
感谢作者：本文来源：https://www.cnblogs.com/pan1042/p/12121382.html 真心感谢作者
//是否获取匹配 abxoxcd
..(xox).. 匹配到结果abxoxcd
..(?:xox)..匹配结果abxoxcd
..(?=xox).. 匹配结果为。abxo ，他的含义是，匹配到两个，用前面的正则匹配xox。所以最终得到四个字符串abxo 他相当于是两个，前置和后置同一时间在同时进行了使用。
测试文本 AAABBCaaA E666FF (A)\\1* 匹配 AAA、A (\\w)\\1+ 匹配 AAA、BB、aa、666、FF (?:A)(B)\\1* 匹配 ABB
解释正向预查和反向预查
// 前瞻： exp1(?=exp2) 查找exp2前面的exp1 exp1 匹配了两次。 // 后顾： (?<=exp2)exp1 查找exp2后面的exp1 // 负前瞻： exp1(?!exp2) 查找后面不是exp2的exp1 // 负后顾： (?<!exp2)exp1 查找前面不是exp2的exp1
// 正向预查和反向预查 测试文本 abxoxcd ..(?=xox) 匹配 ab 要的是前边的， ..(?=oxo) 匹配不到
(?=xox).. 匹配xo 要的是前边的。 (?<=xox).. 匹配 cd 要的是后边的
总结，....(?=aaaa)... 先去匹配括号中的内容。如果匹配，再去匹配括号前边的内容，如果匹配。在去去后边的，
