正则表达式--基础--02--Pattern，Matcher，PatternSyntaxException类

勤径苦舟

已于 2023-07-28 18:20:26 修改

阅读量925

点赞数

分类专栏：正则表达式文章标签：正则表达式 java 开发语言

于 2017-04-16 13:18:08 首次发布

本文链接：https://blog.csdn.net/zhou920786312/article/details/70195025

版权

正则表达式专栏收录该内容

3 篇文章 0 订阅

订阅专栏

正则表达式–基础–02–Pattern，Matcher，PatternSyntaxException类

1、介绍

1.1、Pattern类

Patternd 是一个正则表达式的编译表示。
Pattern类没有公共构造方法。
要创建一个 Pattern对象，必须调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

1.2、Matcher类

Matcher 是对输入字符串进行解释和匹配操作的引擎。
Matcher 没有公共构造方法。
要创建一个 Matcher对象，需要调用 Pattern对象的 matcher 方法来获得一个 Matcher 对象。

1.3、PatternSyntaxException类

是一个非强制异常类
它表示一个正则表达式模式中的语法错误。

1.4、捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，通过对括号内的字符分组来创建。
groupCount方法：表示matcher对象当前有多个捕获组。
group(0)：它代表整个表达式，该组不包括在 groupCount 的返回值中。

1.4.1、测试



public class Test05 {


    public static void main(String[] args) {
        // 按指定模式在字符串查找
        String line = "AAAA111BBB222CCC";
        //(\D*) 表示分组1：匹配非数字
        //(\d+) 表示分组2：匹配数字
        //(.*)  表示分组3：匹配任何字符
        String pattern = "(\\D*)(\\d+)(.*)";

        // 创建 Pattern 对象
        Pattern r = Pattern.compile(pattern);

        // 创建 matcher 对象
        Matcher m = r.matcher(line);
        if (m.find()) {
            System.out.println("整个表达式: " + m.group(0));
            System.out.println("分组大小: " + m.groupCount());
            System.out.println("分组1: " + m.group(1));
            System.out.println("分组2: " + m.group(2));
            System.out.println("分组3: " + m.group(3));
        } else {
            System.out.println("没有匹配到");
        }

    }
}

输出：

整个表达式: AAAA111BBB222CCC
分组大小: 3
分组1: AAAA
分组2: 111
分组3: BBB222CCC

2、Pattern类

是一个正则表达式的编译表示。
Pattern 类没有公共构造方法。
要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

2.1、方法

// 设置正则表达式
public static Pattern compile(String regex)

// 设置要匹配的数据源
public Matcher matcher(CharSequence input)

// 整个字符串完全匹配时，才会返回true  
public boolean matches()

// 拆分要匹配的数据源
public String[] split(CharSequence input)


//设置 正则表达式和 要匹配的数据源
//用于快速匹配字符串，该方法适合用于只匹配一次,且匹配全部字符串.
public static boolean matches(String regex, CharSequence input)

2.2、测试


public class Test03 {


    public static void main(String[] args) {


        String regexPattern = "\\d+";

        //设置正则表达式
        Pattern p = Pattern.compile(regexPattern);

        //设置要匹配的数据源
        Matcher m = p.matcher("12312331AA");
        System.out.println("--------------匹配--------------");
        //尝试将整个区域与 正则表达式 匹配。
        System.out.println("是否全是数字:" + m.matches());

        System.out.println("--------------匹配--------------");
        //拆分要匹配的数据源
        String[] strArr = p.split("aaaaaa:22222bbbbbbb:3333333ccccccc:4444444");
        for (String str : strArr) {
            System.out.println("拆分的数据源：" + str);
        }
        System.out.println("--------------匹配--------------");

        //设置正则表达式和要匹配的数据源
        //用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.

        //返回true
        System.out.println(Pattern.matches("\\d+", "2223"));

        //返回false,需要匹配到所有字符串才能返回true,这里dd不能匹配到
        System.out.println(Pattern.matches("\\d+", "2334dd"));

        //返回false,需要匹配到所有字符串才能返回true,这里we不能匹配到
        System.out.println(Pattern.matches("\\d+", "we233"));
    }
}


 
输出：
 
--------------匹配--------------
是否全是数字:false
--------------匹配--------------
拆分的数据源：aaaaaa:
拆分的数据源：bbbbbbb:
拆分的数据源：ccccccc:
--------------匹配--------------
true
false
false

3、Matcher类

3.1、索引方法

3.1.1、方法

索引方法提供了有用的索引值，精确表明输入字符串中在哪能找到匹配：

返回以前匹配的初始索引。
public int start()

返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
public int start(int group)
 
返回最后匹配字符之后的偏移量。
public int end()

返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
public int end(int group)

3.1.2、测试

public class Test04 {


    public static void main(String[] args) {
        //匹配数字
        String regexPattern = "\\d+";
        Pattern p = Pattern.compile(regexPattern);

        Matcher m = p.matcher("111AAA222BBB");
        int count = 0;
        while (m.find()) {
            count++;
            System.out.println("-------第" + count + "次匹配到------");
            System.out.println("匹配的初始索引: " + m.start());
            System.out.println("最后匹配字符之后的偏移量: " + m.end());
        }
    }
}


输出：

-------第1次匹配到------
匹配的初始索引: 0
最后匹配字符之后的偏移量: 3
-------第2次匹配到------
匹配的初始索引: 6
最后匹配字符之后的偏移量: 9

3.2、查找方法

查找方法用来检查输入字符串并返回一个布尔值，表示是否找到该模式

3.2.1、方法

//尝试将从区域开头开始的输入序列与该模式匹配。
//此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。
public boolean lookingAt()
 
// 只需要字符串中，找到某部分的子字符串匹配则返回true
//此方法从匹配器区域的开头开始，如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始。
public boolean find()

//重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
public boolean find(int start）


// 整个字符串完全匹配时，才会返回true
public boolean matches()


//打印匹配到的的字符串，需要在lookingAt或者find或者matches方法执行后，才能执行
public String group()

3.2.2、测试

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test04 {


    public static void main(String[] args) {
        String regexPattern = "\\d+";
        //设置正则表达式
        Pattern p = Pattern.compile(regexPattern);

        //尝试将从区域开头开始的输入序列与该模式匹配。
        //此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。
        System.out.println("--------------lookingAt--------------");
        Matcher m1 = p.matcher("23ssss");
        System.out.println(m1.lookingAt());//返回true：因为\d+匹配到了前面的23

        Matcher m2 = p.matcher("sss23");
        System.out.println(m2.lookingAt());//返回false：因为\d+不能匹配前面的sss

        System.out.println("--------------find--------------");
        //尝试查找与该模式匹配的输入序列的下一个子序列。
        //此方法从匹配器区域的开头开始，如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始。
        Matcher mm = p.matcher("22bb23");
        System.out.println(mm.find());//返回true：因为包含数字

        Matcher mm2 = p.matcher("aa2223");
        System.out.println(mm2.find());//返回true：因为包含数字

        Matcher mm3 = p.matcher("aa2223bb");
        System.out.println(mm3.find());//返回true：因为包含数字

        Matcher mm4 = p.matcher("aabb");
        System.out.println(mm4.find());//返回false：因为不包含数字

        System.out.println("--------------matches--------------");
        Matcher mm5 = p.matcher("111");
        System.out.println(mm5.matches());//返回true：匹配整个字符串，因为都是数字

        Matcher mm6 = p.matcher("111AA");
        System.out.println(mm6.matches());//返回false：匹配整个字符串，因为包含非数字

        Matcher mm7 = p.matcher("AA111");
        System.out.println(mm7.matches());//返回false：匹配整个字符串，因为包含非数字

        System.out.println("--------------group--------------");

        Matcher mm8 = p.matcher("aa2223bb");
        System.out.println(mm8.find());//返回true：因为包含数字
        System.out.println(mm8.group());//打印find匹配的字符串



    }
}


输出：
 
--------------lookingAt--------------
true
false
--------------find--------------
true
true
true
false
--------------matches--------------
true
false
false
--------------group--------------
true
2223

Process finished with exit code 0

3.3、替换方法

替换方法是替换输入字符串里文本的方法

3.3.1、方法

实现 非终端 添加和替换步骤。
public Matcher appendReplacement(StringBuffer sb, String replacement)
 
实现 终端 添加和替换步骤。
public StringBuffer appendTail(StringBuffer sb)


替换 模式与给定替换字符串 相匹配的输入序列的 每个子序列。
public String replaceAll(String replacement)
 

替换 模式与给定替换字符串 相匹配的输入序列的 第一个子序列。
public String replaceFirst(String replacement)
 

返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。
public static String quoteReplacement(String s)

3.3.2、测试

public class Test04 {


    public static void main(String[] args) {

        String regexPattern = "11";
        //设置正则表达式
        Pattern p = Pattern.compile(regexPattern);

        // 要匹配的输入源
        Matcher m = p.matcher("11AA22BB33CC11DD");

        System.out.println("--------------replaceAll--------------");
        //把11全部替换为99
        String newInput = m.replaceAll("99");
        System.out.println("替换后的字符串：" + newInput);

        System.out.println("--------------replaceFirst--------------");
        //把第一个11替换为99
        String newInput2 = m.replaceFirst("99");
        System.out.println("替换后的字符串：" + newInput2);

        System.out.println("--------------quoteReplacement--------------");
        //把第一个11替换为99
        String newInput3 = m.quoteReplacement("99");
        System.out.println("替换成功的字符串：" + newInput3);

        System.out.println("--------------appendReplacement--------------");
        StringBuffer sb = new StringBuffer();
        while(m.find()){
            m.appendReplacement(sb,"99");
        }
        System.out.println("替换后的字符串：" + sb.toString());
        System.out.println("--------------appendTail--------------");
        m.appendTail(sb);
        System.out.println("替换后的字符串：" + sb.toString());



    }
}

输出：
--------------replaceAll--------------
替换后的字符串：99AA22BB33CC99DD
--------------replaceFirst--------------
替换后的字符串：99AA22BB33CC11DD
--------------quoteReplacement--------------
替换成功的字符串：99
--------------appendReplacement--------------
替换后的字符串：AA22BB33CC99
--------------appendTail--------------
替换后的字符串：AA22BB33CC99DD

4、PatternSyntaxException类

是一个非强制异常类，它指示一个正则表达式模式中的语法错误。

4.1、方法

提供了下面的方法来帮助我们查看发生了什么错误。

获取错误的描述
public String getDescription()

获取错误的索引
public int getIndex()

获取错误的正则表达式模式
public String getPattern()

返回多行字符串，包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示。
public String getMessage()