爬虫大佬，把他总结的正则表达式使用给我了！

(?:X) X，作为非捕获组
(?idmsux-idmsux) Nothing，但是将匹配标志i d m s u x on - off
(?idmsux-idmsux:X) X，作为带有给定标志 i d m s u x on - off 的非捕获组 (?=X) X，通过零宽度的正 lookahead
(?!X) X，通过零宽度的负 lookahead
(?<=X) X，通过零宽度的正 lookbehind
(?<!X) X，通过零宽度的负 lookbehind
(?>X) X，作为独立的非捕获组

三、案例

1. 字符匹配

"a".matches(".")

结果：true
描述：. 匹配任意字符

"a".matches("[abc]")

结果：true
描述：包含 abc 任意一个字符都匹配，默认匹配一次

"a".matches("[^abc]")

结果：true
描述：任何字符，除了 a、b 或 c（否定）

"A".matches("[a-zA-Z]")

结果：false
描述：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

"A".matches("[a-z]|[A-Z]")

结果：true
描述：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

"A".matches("[a-z(A-Z)]")

结果：true
描述：a-z，A-Z，匹配范围相同，括号是捕获组

"R".matches("[A-Z&&(RFG)]")

结果：true
描述：匹配 A-Z 与 RFG 交集

"a_8".matches("\\w{3}")

结果：true
描述：\w 单词字符等同于 [a-zA-Z_0-9]，{3} 匹配三次

"\\".matches("\\\\")

结果：true
描述：\ 表示的是一个 \

"hello sir".matches("h.*")

结果：true
描述：. 任何字符，* 匹配零次到多次

"hello sir".matches(".*ir$")

结果：true
描述：.* 匹配任意字符 ir$ 确定匹配行的结尾

"hello sir".matches("^h[a-z]{1,3}o\\b.*")

结果：true
描述：^h 匹配开头，[a-z]{1,3}o 匹配1到3次的a-z之后匹配字母o，\b 并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。匹配的是o后面的位置。

"hellosir".matches("^h[a-z]{1,3}o\\b.*")

结果：false
描述：o后面跟着s，是字母，不是空格，\b 不能匹配单词的o的边界。

" \n".matches("^[\\s&&[^\\n]]*\\n$")

结果：true
描述：匹配开头是一个空格 ^[\\s&&[^\\n]]，且不能是换行符，最后必须是换行 \\n$

System.out.println("java".matches("(?i)JAVA"));

结果：true
描述：(?i)非捕获组里面这个表示忽略大小写

2. 模式匹配

2.1 验证匹配

Pattern p = Pattern.compile("[a-z]{3,}");
Matcher m = p.matcher("fgha");
System.out.println(m.matches()); // true，匹配字符3次及以上

结果：true
描述：Pattern 与 Matcher 一起合作 .Matcher 类提供了对正则表达式的分组支持，以及对正则表达式的多次匹配支持.。单独用Pattern只能使用 Pattern.matches(String regex,CharSequence input) 一种最基础最简单的匹配。

2.2 匹配功能

Pattern p = Pattern.compile("\\d{3,5}");
Matcher m = p.matcher("123-4536-89789-000");
System.out.println(m.matches());
m.reset();// 把吃进去的字符吐出来重新匹配，否经过m2.matches会吃进去字符 下面的匹配就不成功
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());  // 找到了 就把首位位置打印下（必须找到才能打印）
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end()); // 找到了 就把首位位置打印下（必须找到才能打印）
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end()); // 找到了 就把首位位置打印下（必须找到才能打印）
System.out.println(m.find());
System.out.println(m.lookingAt());              //每次都是才头上开始找

测试结果

false
true
0-3
true
4-8
true
9-14
true
true

m.matches()，是全量匹配
m.reset()，把吃进去的字符吐出来重新匹配，否经过m2.matches会吃进去字符下面的匹配就不成功
m.find()，查找匹配
m.start()，匹配到的字符串，开始位置
m.end()，匹配到的字符串，结束位置

2.3 匹配普通替换

Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java_Java_jAva_jAVa_IloveJava");
System.out.println(m.replaceAll("JAVA"));

结果：JAVA_JAVA_JAVA_JAVA_IloveJAVA
描述：把所有匹配到的小写字母 java、JavA，都匹配为大写

2.4 匹配逻辑替换

Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java_Java_jAva_jAVa_IloveJava fdasfas");
StringBuffer sb = new StringBuffer();
int i = 0;
while (m.find()) {
    i++;
    if (i % 2 == 0) {
        m.appendReplacement(sb, "java");
    } else {
        m.appendReplacement(sb, "JAVA");
    }
}
m.appendTail(sb);
System.out.println(sb);

结果：JAVA_java_JAVA_java_IloveJAVA fdasfas
描述：按照程序逻辑 i % 2，进行单双数替换匹配

2.4 分组匹配

Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
Matcher m = p.matcher("123bb_78987dd_090po");
while(m.find()){
    System.out.println(m.group(1));
}

结果：

123
78987
090

Process finished with exit code 0

描述：分组加括号只取数字一组，grop括号里面第0组是整体，第一组是左起第一个括号，第二组是左起第二个括号

2.5 贪婪的匹配与不贪婪匹配

Pattern p = Pattern.compile("(.{3,10}?)[0-9]");
Matcher m = p.matcher("aaaa5dddd8");
while (m.find()) {
    System.out.println(m.start() + "-" + m.end());
}

结果：

0-5
5-10

Process finished with exit code 0

描述：.{3,10}后面没问号就是贪婪匹配会配到最长，如果{3,10}?加?号就是懒蛋匹配之匹配最少的，从3个开始找。如果这里用if(m.find)(){m.start()+"-"+m.end()} 那么之匹配第一个

2.6 普通捕获

Pattern p = Pattern.compile(".{3}");
Matcher m = p.matcher("ab4dd5");
while(m.find()){
    System.out.println(m.group());
}

结果：

ab4
5-10

Process finished with exit code 0

描述：每次匹配三个任意字符，用 m.group() 输出。

2.7 非捕获组(?=a)

 Pattern p = Pattern.compile(".{3}(?=a)");           
 Matcher m = p.matcher("ab4add5");
 while (m.find()) {
     System.out.println("后面不能是a的：" + m.group());
 }

结果： 后面不能是a的：ab4
描述：(?=a)这个是非捕获组的意思，最后一个是a而且还不把这个a取出来！！(?=a)这个要是写在前面就不一样了

Pattern p = Pattern.compile("(?!a).{3}");           
Matcher m = p.matcher("abbsab89");
while (m.find()) {
    System.out.println("前面不能是a的：" + m.group());
}

结果：前面不能是a的：bbs、前面不能是a的：b89
描述：(?!a)前面不能是a的，所以找到整个字符串中 bbs、b89

2.8 去除><号匹配

Pattern p = Pattern.compile("(?!>).+(?=<)");
Matcher m = p.matcher(">小傅哥<");
while (m.find()) {
    System.out.println(m.group());
}

结果：小傅哥
描述：一般可以匹配网页中的特殊字符串里面的内容信息。

2.9 向前引用

Pattern p = Pattern.compile("(\\d\\d)\\1");
Matcher m = p.matcher("1212");
System.out.println(m.matches());

结果：true
描述：这里面的1是向前引用，12是第一匹配到的，下一次在匹配出来12和前面相同所以是true

四、总结

正则中包括了很多的符号、类型、匹配范围、匹配数量、匹配原则等等，像贪婪、排除、向前引用等等，这些个使用方法其实也不难，只要按照正则的标准就可以组合出你想要匹配和拦截出来的字符串内容信息。

转载自：https://my.oschina.net/itstack/blog/4994530

yong472727322

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
爬虫大佬，把他总结的正则表达式使用给我了！

目录一、前言二、规则1. 常用符号2. 字母字符3. 预定义字符4. POSIX 字符5. Character 类6. Unicode 块和类别的类7. 边界匹配器8. Greedy 数量词9. Reluctant 数量词10. Possessive 数量词11. Logical 运算符12. Back 引用13. 引用14. 特殊构造（非捕获）三、案例1. 字符匹配2. 模式匹配四、总结一、前言编程总在实践中出结.
复制链接

扫一扫