正则表达式 Pattern 、Matcher

最新推荐文章于 2024-08-11 16:05:49 发布

TransientBa

最新推荐文章于 2024-08-11 16:05:49 发布

阅读量5.7k

点赞数 4

分类专栏： javascript 文章标签：正则 regx Pattern Matcher

本文链接：https://blog.csdn.net/zyb2017/article/details/79032648

版权

javascript 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一 Pattern和Matcher

1.1 相关

在使用正则表达式之前我们需了解Pattern和Matcher，为什么要了解他们呢? 他们用来解决String不能解决的问题，是很实用切强大的正则表达式对象

1.2 类库

他们同属于一个类库包：java.util.regex

1.3 使用流程

关于流程，为了直观我画了一张图，我们看图说：
使用流程
图中标出了3个模块，从上到下分别用1、2、3来表示
先说1:根据String类型的正则表达式生成Pattern对象，例如下面的 FIND_PATTERN

    /**
     * @author transientba
     * 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度。
     * 说明：不要在方法体内定义：Pattern pattern = Pattern.compile(规则);
     */
    private static Pattern FIND_PATTERN = Pattern.compile("\\w+");

再说2：根据Pattern的Matcher（）方法，将要匹配的字符串传入，生成Matcher对象

Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");

marcher对象一句pattern对象作为匹配模式对字符串展开匹配

最后说3：根据Matcher的不同方法得到不同的结果，个人理解他更像是在匹配后的基础上进行字符串的操作

        while (matcher.find()) {
            System.out.print(matcher.group()+" ");
        }

输出结果如下：

Let s keep moving

二正则表达式

2.1 上面的例子演示了如何使用Pattern和Matcher对字符串进行匹配操作，接下来我们看看正则：

main里面

   public static void main(String[] args){
        String str1 = "Hello~ my n ame is transientba";
        String str2 = "Hello, X or XX, I 3 say transientba";
        splitStringOne(str1);
        splitStringTwo(str2);
   }

splitStringOne和splitStringTwo两个方法

    public static void splitStringOne(String str){
        System.out.println("开始splitStringOne");
        //以空格分割
        System.out.println(Arrays.toString(str.split("\\s")));
        //以spring分割
        System.out.println(Arrays.toString(str.split("spring")));
        //以非单词分割   ^A-Za-z0-9_
        System.out.println(Arrays.toString (str.split("\\W+")));
    }


    public static void splitStringTwo(String str){
        System.out.println("开始splitStringTwo");
        //以两个X分割
        System.out.println(Arrays.toString(str.split("X{2}")));
        //以数字分割
        System.out.println(Arrays.toString(str.split("\\d")));
        //以非数字分割
        System.out.println(Arrays.toString(str.split("\\D")));
    }

输出结果如下

开始splitStringOne
[Hello~, my, n, ame, is, transientba]
[Hello~ my n ame is transientba]
[Hello, my, n, ame, is, transientba]

开始splitStringTwo
[Hello, X or , , I 3 say transientba]
[Hello, X or XX, I ,  say transientba]
[, , , , , , , , , , , , , , , , , , 3]

三用法

下面看看用法，我先在类中定义了两个Pattern（多个matcher可以共用一个Pattern），下面的方法将应用这两个Pattern

    /**
     * @author transientba
     * 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度。
     * 说明：不要在方法体内定义：Pattern pattern = Pattern.compile(规则);
     */
    private static Pattern FIND_PATTERN = Pattern.compile("\\w+");

    private static Pattern REPLACE_PATTERN = Pattern.compile("moving");

3.1 find方法

先看代码和运行结果，然后解释

   public static void demoFind(){
        Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");
        System.out.println(matcher);
        while (matcher.find()) {
            System.out.print(matcher.group()+" ");
        }
    }

运行结果：

Let s keep moving

这里主要用到了find和group，这两个分别代表什么？matches()与find()的区别？

3.1.1 find()

是对字符串部分匹配，查找输入的字符串与规定的Pattern规则模式匹配的子字符串，如果匹配的字符串有组则可使用group()

3.1.2 matchers()

是对字符串全部匹配，比如验证一个字符串是否为电话号码，是否符合密码规则等

3.2 find(int i)方法

 /**
     * @author transientba
     * find(int i)
     */
    public static void demoFindInt(){
        Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");
        int i = 0;
        //重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
        while (matcher.find(i)) {
            System.out.print(matcher.group()+" ");
            i++;
        }
    }

输出结果：

Let et t s s keep keep eep ep p moving moving oving ving ing ng g

3.3 star 和 end 方法

 /**
     * @author transientba
     * Star 和 End
     */
    public static void doStarAndEnd(){
        Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");
        while (matcher.find()) {
            System.out.println(matcher.group() + " " + matcher.start() + " " + matcher.end());
        }
    }

输出结果：

Let 0 3
s 4 5
keep 6 10
moving 11 17

3.4 replaceFirst方法

    /**
     * @author transientba
     * demoReplaceFirst
     */
    public static void demoReplaceFirst(){
        Matcher matcher = REPLACE_PATTERN.matcher("Let's keep moving");
        String replaceFirstString = matcher.replaceFirst("eating");
        System.out.println(replaceFirstString);
    }

运行结果：

Let's keep eatingLet's keep eating

3.5 replaceAll方法

    /**
     * @author transientba
     * demoReplaceAll
     */
    public static void demoReplaceAll(){
        Matcher matcher = REPLACE_PATTERN.matcher("let's keep moving moving");
        String replaceAll = matcher.replaceAll("eating");
        System.out.println(replaceAll);
    }

输出结果：

let's keep eating eating

3.6 appendReplacement方法

    /**
     * @author transientba
     * 匹配项替换后 后面的会被断掉
     * appendReplacement
     */
    public static void domoAppendReplacement(){
        Matcher matcher = REPLACE_PATTERN.matcher("let's keep moving moving gogogogogo");
        StringBuffer buffer = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(buffer, "eating?");
        }
        System.out.println(buffer.toString());
    }

输出结果:
注意原本在第二个moving后面的gogogogo被截断了

let's keep eating? eating?

3.7 appendTail方法

   /**
     * @author transientba
     * 匹配项替换后 匹配后剩余结果追加到StringBuffer后 后面的不会被断掉
     * appendTail
     */
    public static void demoAppendTail(){
        Matcher matcher = REPLACE_PATTERN.matcher("let's keep moving moving gogogogogo");
        StringBuffer buffer = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(buffer, "eating?");
        }
        matcher.appendTail(buffer);
        System.out.println(buffer.toString());
    }

输出结果：

let's keep eating? eating? gogogogogo

四其他正则语法

语法引自：http://www.runoob.com/regexp/regexp-syntax.html

4.1 非打印字符

字符	描述
\cx	匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ 。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。

4.2 特殊字符

字符	描述
$\| 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则$ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 \$。
( )	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。
*	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。
[	标记一个中括号表达式的开始。要匹配 [，请使用 [。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
\| 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\’ 匹配 “\”，而 ‘(’ 则匹配 “(“。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
{	标记限定符表达式的开始。要匹配 {，请使用 {。

4.3 限定符

字符	描述
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，”do(es)?” 可以匹配 “do” 、 “does” 中的 “does” 、 “doxy” 中的 “do” 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，’o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，’o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。’o{1,}’ 等价于 ‘o+’。’o{0,}’ 则等价于 ‘o*’。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，”o{1,3}” 将匹配 “fooooood” 中的前三个 o。’o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。

4.4 定位符

字符	描述
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。
$\| 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。
\b	匹配一个字边界，即字与空格间的位置。
\B	非字边界匹配。

注意：不能将限定符与定位符一起使用。由于在紧靠换行或者字边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。

五本篇源码

package com.example.domain;



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



/**
 * @author transientba
 * @date 2018/01/08
 */
public class StarString {
    public static void splitStringOne(String str){
        System.out.println("开始splitStringOne");
        //以空格分割
        System.out.println(Arrays.toString(str.split("\\s")));
        //以spring分割
        System.out.println(Arrays.toString(str.split("spring")));
        //以非单词分割   ^A-Za-z0-9_
        System.out.println(Arrays.toString (str.split("\\W+")));
    }
    public static void splitStringTwo(String str){
        System.out.println("开始splitStringTwo");
        //以两个X分割
        System.out.println(Arrays.toString(str.split("X{2}")));
        //以数字分割
        System.out.println(Arrays.toString(str.split("\\d")));
        //以非数字分割
        System.out.println(Arrays.toString(str.split("\\D")));
    }

    /**
     * @author transientba
     * 在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度。
     * 说明：不要在方法体内定义：Pattern pattern = Pattern.compile(规则);
     */
    private static Pattern FIND_PATTERN = Pattern.compile("\\w+");

    private static Pattern REPLACE_PATTERN = Pattern.compile("moving");

    /**
     * @author transientba
     * find
     */
    public static void demoFind(){
        Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");
        //尝试查找与该模式匹配的输入序列的的下一个子序列。
        while (matcher.find()) {
            System.out.print(matcher.group()+" ");
        }
    }

    /**
     * @author transientba
     * find(int i)
     */
    public static void demoFindInt(){
        Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");
        int i = 0;
        //重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
        while (matcher.find(i)) {
            System.out.print(matcher.group()+" ");
            i++;
        }
    }

    /**
     * @author transientba
     * Star 和 End
     */
    public static void doStarAndEnd(){
        Matcher matcher = FIND_PATTERN.matcher("Let's keep moving");
        while (matcher.find()) {
            System.out.println(matcher.group() + " " + matcher.start() + " " + matcher.end());
        }
    }

    /**
     * @author transientba
     * demoReplaceFirst
     */
    public static void demoReplaceFirst(){
        Matcher matcher = REPLACE_PATTERN.matcher("Let's keep moving");
        String replaceFirstString = matcher.replaceFirst("eating");
        System.out.println(replaceFirstString);
    }

    /**
     * @author transientba
     * demoReplaceAll
     */
    public static void demoReplaceAll(){
        Matcher matcher = REPLACE_PATTERN.matcher("let's keep moving moving");
        String replaceAll = matcher.replaceAll("eating");
        System.out.println(replaceAll);
    }


    /**
     * @author transientba
     * 匹配项替换后 后面的会被断掉
     * appendReplacement
     */
    public static void domoAppendReplacement(){
        Matcher matcher = REPLACE_PATTERN.matcher("let's keep moving moving gogogogogo");
        StringBuffer buffer = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(buffer, "eating?");
        }
        System.out.println(buffer.toString());
    }


    /**
     * @author transientba
     * 匹配项替换后 匹配后剩余结果追加到StringBuffer后 后面的不会被断掉
     * appendTail
     */
    public static void demoAppendTail(){
        Matcher matcher = REPLACE_PATTERN.matcher("let's keep moving moving gogogogogo");
        StringBuffer buffer = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(buffer, "eating?");
        }
        matcher.appendTail(buffer);
        System.out.println(buffer.toString());
    }





    public static void main(String[] args){
        String str1 = "Hello~ my n ame is transientba";
        String str2 = "Hello, X or XX, I 3 say transientba";
        splitStringOne(str1);
        splitStringTwo(str2);
        demoFind();
        demoFindInt();
        doStarAndEnd();
        demoReplaceFirst();
        demoReplaceAll();
        domoAppendReplacement();
        demoAppendTail();


    }







}