韩顺平Java学习笔记_正则表达式专题(非常实用!)

        //假定,编写爬虫,从百度页面得到文本
        String content = "根据PC-Meter1996年的调查，平均每个互联网用户每次访问的环球网的网站有5.6个，" +
                "每次查看的网页20.8个，而平均阅读每一个网页所需要的时间大约1.4分钟，平均每次上网阅读环球网页的时间大约28分钟。" +
                "作为这样一种具有私人和公共的双重功用的传媒，互联网效用的实现从根本上还是依赖于参与者，" +
                "也就是用户的增加。而这一特性又是和网络的性质是完全一致的。";
        //提取所有英文单词|所有数字|字母和数字
        //1.县创建一个Pattern对象
//        Pattern pattern = Pattern.compile("[a-zA-Z]");
//        Pattern pattern = Pattern.compile("[0-9]+");
        Pattern pattern = Pattern.compile("[a-zA-Z]|[0-9]+");
        //2.创建一个匹配器对象
        Matcher matcher = pattern.matcher(content);
        //3.循环匹配
        while(matcher.find()){
            System.out.println(matcher.group(0));
        }

2.基本介绍 

 3.底层原理

package com.hspedu.regexp;
import java.util.regex.Matcher; import java.util.regex.Pattern;
/**
* @author 韩顺平 * @version 1.0
* 分析 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();
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.元字符 -转义符:在检索某些特殊字符的时候,要用到转移符号,否则会报错

Note:在Java的正则表达式中,用两个\\表示其他语言中的一个\

例子:

/**
 * 演示转义符
 */
public class RegExp02 {
    public static void main(String[] args) {
        String content = "abc$(abc(123(";
        //匹配(
        String regStr = "\\(";//要用\\转义,否则报错
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        while(matcher.find()){
            System.out.println(matcher.group(0));
        }
    }
}

需要用到转移符号的字符如下: . * + ( ) $ / \ ? [ ] ^ { }

2.元字符 -字符匹配符

 3.元字符 -选择匹配符: 匹配某个字符串时是选择性的,比如既可以匹配这个,又可以匹配那个,则需要用到选择匹配符

|  表示或者

4. 限定符 :用于指定其前面的字符和组合项连续出现多少次

5.定位符:规定要匹配的字符串出现的位置,比如再开始还是结束位置,非常有用! 

6.分组 

(pattern) 非命名捕获.

捕获匹配的子字符串,编号为零的第一个捕获是由整个正则表达式模式匹配的文本,其他捕获结果则根据左括号顺序由1开始自动编号.

(?<name>pattern) 命名捕获.

将匹配的子字符串捕获到一个组名称或编号名称中,用于name的字符串不能包含任何标点符号,并且不能以数字开头.可以使用单引号替代尖括号,例如(?'name').

特别分组

练习:

7.非贪婪匹配

正则匹配默认是贪婪匹配,如果在限定符后加?即变成非贪婪匹配,这时会尽可能匹配少的

8.应用实例 

三 三个常用类

Pattern:正则表达式

Matcher:对输入字符串进行解释和匹配的引擎

PatternSyntaxException:表示一个正则表达式模式中的语法错误

 1. Pattern类的方法matches --> 整体匹配,返回boolean

public class PatternMethod {
    public static void main(String[] args) {
        String content = "hello abc hello, 韩顺平教育";
        String regExp = "hello.*";
        boolean matches = Pattern.matches(regExp, content);
        System.out.println("整体匹配=" + matches);
    }
}

2. Matcher类

常用方法的演示: 

public class MatcherMethod {
    public static void main(String[] args) {
        String content = "hello hspedu jack tom hello smith hello";
        String regExp = "hello";
        Pattern pattern = Pattern.compile(regExp);
        Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            System.out.println("--------");
            System.out.println(matcher.start());
            System.out.println(matcher.end());
            System.out.println(content.substring(matcher.start(), matcher.end()));
        }
        //整体匹配,常用于校验某个字符串是否满足某个规则
        System.out.println("整体匹配: " + matcher.matches());

        //完成如果conteng 有hspedu 就替换成韩顺平教育
        String regStr = "hspedu";
        Pattern pattern1 = Pattern.compile(regStr);
        Matcher matcher1 = pattern1.matcher(content);
        String newStr = matcher1.replaceAll("韩顺平教育");//返回的字符串才是替换后的,原来的content不变化
        System.out.println("new: " + newStr);
        System.out.println("old: " + content);

    }
}

四 分组, 捕获, 反向引用

 案例练习一:

public class 反向引用 {
    public static void main(String[] args) {
        String content = "hello jack 12321-333999111 tom11111 jack22 yyy xxx";//找到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);
        //我我要学学学学编程Java!
        //2.去掉重复的字
        //思路
        //(1)使用(.)\\1+
        //(2)使用反向引用$1来替换得到的内容
//        Pattern pattern1 = Pattern.compile("(.)\\1+");//分组会被记录到$1
//        Matcher matcher1 = pattern1.matcher(content);
//        while (matcher1.find()) {
//            System.out.println("找到" + matcher1.group(0));
//        }
//        //使用反向引用$1来替换得到的内容
//        content = matcher1.replaceAll("$1");
//        System.out.println(content);
        //3,使用一条语句去重
        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");
        System.out.println(content);

五 String类中使用正则表达式

1.替换

String类 public String replaceAll(String regex,String replacement)

2.判断

String类 public boolean matches(String regex)

3.分割

String类 public String[] split(String regex)