Java 正则表达式

最新推荐文章于 2023-11-04 17:06:23 发布

剑Black

最新推荐文章于 2023-11-04 17:06:23 发布

阅读量405

点赞数

文章标签：正则表达式 java 开发语言

本文链接：https://blog.csdn.net/weixin_47076538/article/details/129353905

版权

正则表达式在线测试

正则表达式是一串字符，描述了一个文本模式，可以方便地处理文本，包括查找、替换、切分等。

正则表达式中的字符有两类：一类是普通字符，匹配字符本身；另一类是元字符，有特殊含义，元字符及其特殊含义构成了正则表达式的语法。

单个字符

大部分的单个字符是用字符本身表示的，比如字符 ‘0’、‘3’、‘a’、'马’等，但有一些单个字符使用多个字符表示，这些字符都以斜杠 \ 开头。

特殊字符

比如 tab 字符 ‘\t’、换行符 ‘\n’、回车符 ‘\r’ 等。

八进制表示的字符

\0 开头，后跟1～3位数字，比如 \0141，对应的是 ASCII 编码为97的字符，即字符 ‘a’。

十六进制表示的字符

\x 开头，后跟两位字符，比如 \x6A，对应的是 ASCII 编码为 106 的字符，即字符 ‘j’。

Unicode 编号表示的字符

\u 开头，后跟 4 位字符，比如 \u9A6C，表示的是中文字符’马’，只能表示编号在 0xFFFF 以下的字符，如果超出 0xFFFF，使用 \x{…} 形式，比如 \x{1f48e}。5

元字符

如 ‘\’、‘.’、‘?’ 等，要匹配元字符本身，需要使用转义字符。

字符组

字符组有多种，包括任意字符、多个指定字符之一、字符区间等。

任意字符

'.' 默认匹配换行符以外的任意字符。比如：正则表达式 a.f 既匹配字符串 “abf”，也匹配 “acf”。

可以指定另外一种匹配模式，一般称为单行匹配模式或者点号匹配模式，此模式下，'.' 匹配任意字符，包括换行符。

有两种方式指定匹配模式：

一种是在正则表达式中，以 (? s)开头，s 表示 single line，即单行匹配模式，比如：(? s)a.f

一种是在程序中指定，在 Java 中，单行匹配模式对应的模式常量是 Pattern.DOTALL 。

字符区间

用中括号 [] 表示组，匹配组中的任意一个字符。比如：[abcd]，匹配 a、b、c、d 中的任意一个字符；

字符组中可以使用连字符 ‘-’ 表示连续的多个字符，比如：[0-9]、[a-z]；

可以有多个连续空间，可以有其他普通字符，比如：[0-9a-zA-Z]；

‘-’ 是一个元字符，如果要匹配它自身，可以使用转义，即 ‘-’，或者把它放在字符组的最前面

字符组支持排除的概念，在 [ 后紧跟一个字符 ^，比如：[^abcd]，匹配除了a, b, c, d以外的任意一个字符；

^ 只有在字符组的开头才是元字符，如果不在开头，就是普通字符，匹配它自身；

在字符组中，除了 [ ]、\ 、- 、^ 外，其他在字符组外的元字符不再具备特殊含义。

有一些特殊的以 \ 开头的字符，表示一些预定义的字符组：

❑ \d: d 表示 digit，匹配一个数字字符，等同于 [0-9]。

❑ \w: w 表示 word，匹配一个单词字符，等同于 [a-zA-Z_0-9]。

❑ \s: s 表示 space，匹配一个空白字符，等同于 [ \t\n\x0B\f\r]。

❑ \D：匹配一个非数字字符，即 [^\d]。

❑ \W：匹配一个非单词字符，即 [^\w]。

❑ \S：匹配一个非空白字符，即 [^\s]。

量词

量词指的是指定出现次数的元字符，有三个常见的元字符：+、*、? 。

表示前面字符的一次或多次出现，比如 ab+c，既能匹配 abc，也能匹配 abbc，或 abbbc。

表示前面字符的零次或多次出现，比如 ab*c，既能匹配 abc，也能匹配 ac，或 abbbc。

表示前面字符可能出现，也可能不出现，比如 ab? c，既能匹配 abc，也能匹配 ac，但不能匹配 abbc。

{m,n}

更通用的语法是 {m,n}，出现次数从m 到 n，包括 m 和 n，如果 n 没有限制，可以省略，如果 m 和 n 一样，可以写为 {m}。

语法必须是严格的 {m,n} 形式，逗号左右不能有空格。

量词的默认匹配是贪婪的，如果希望在碰到第一个匹配时就停止，应该使用懒惰量词，在量词的后面加一个符号 '? '。

分组

表达式可以用括号 () 括起来，表示一个分组，比如 a(bc)d, bc 就是一个分组，分组可以嵌套，比如 a(de(fg))。

分组默认都有一个编号，按照括号的出现顺序，从 1 开始，从左到右依次递增。分组 0 是一个特殊分组，内容是整个匹配的字符串。

a(bc)((de)(fg))

字符串 abcdefg 匹配这个表达式，第 1 个分组为 bc，第 2 个为 defg，第 3 个为 de，第 4 个为 fg，分组 0 是 abcdefg 。

分组匹配的子字符串可以在后续访问，好像被捕获了一样，所以默认分组称为捕获分组。

小括号 () 和元字符 ‘|’ 一起，可以表示匹配其中的一个子表达式，如：(http|ftp|file)。

可以使用斜杠 \ 加分组编号引用之前匹配的分组，这称为回溯引用。比如：<(\w+)>(.*)</\1>，\1匹配之前的第一个分组 (\w+)。

使用数字引用分组，容易出现混乱，可以对分组进行命名，通过名字引用，对分组命名的语法是 (?<name>X)，引用分组的语法是 \k<name>。

比如：<(? <tag>\w+)>(.*)</\k<tag>>。

默认分组都称为捕获分组，即分组匹配的内容被捕获了，可以在后续被引用。

实现捕获分组有一定的成本，为了提高性能，如果分组后续不需要被引用，可以改为非捕获分组，语法是 (? :…)，比如：(? :abc|def)。

特殊边界匹配

边界匹配不同于字符匹配，可以认为，在字符串中，每个字符的两边都是边界。比如：“a cat\n”。

在正则表达式中，除了可以指定字符需满足什么条件，还可以指定字符的边界，常用的表示特殊边界的元字符有 ^、$、\A、\Z、\z 和 \b。

匹配整个字符串的开始，^abc 表示整个字符串必须以 abc 开始。注意在字符组中 ^ 表示排除，但在字符组外，它匹配开始。

默认匹配整个字符串的结束，如果整个字符串以换行符结束，匹配的是换行符之前的边界，比如表达式 abc$，表示整个表达式以 abc 结束，或者以 abc\r\n 或 abc\n 结束。

以上 ^ 和 $ 的含义是默认模式下的，可以指定另外一种匹配模式：多行匹配模式，在此模式下，会以行为单位进行匹配，^ 匹配的是行开始，$ 匹配的是行结束，比如表达式是 ^abc$，字符串是 “abc\nabc\r\n”，就会有两个匹配。

可以有两种方式指定匹配模式。一种是在正则表达式中，以(? m)开头，m表示multi-line，即多行匹配模式。另外一种是在程序中指定，在Java中，对应的模式常量是 Pattern.MULTILINE。

单行模式影响的是字符 ‘.’ 的匹配规则，使得 ‘.’ 可以匹配换行符；多行模式影响的是 ^ 和 $ 的匹配规则，使得可以匹配行的开始和结束，两个模式可以一起使用。

开始边界

\A 与 ^ 类似，不管什么模式，匹配的总是整个字符串的开始边界。

结束边界

\Z 和 \z 与 $ 一样，匹配的是换行符之前的边界，而 \z 匹配的总是结束边界。

单词边界

\b 匹配的是单词边界，比如 \bcat\b，匹配的是完整的单词c at，不能匹配 category。\b 匹配的不是一个具体的字符，而是一种边界，这种边界满足一个要求，一边是单词字符，另一边不是单词字符。在Java中，\b 识别的单词字符除了 \w，还包括中文字符。

环视边界匹配

环视匹配的是一个边界，表达式是对这个边界左边或右边字符串的要求，对同一个边界，可以指定多个要求，即写多个环视。

肯定顺序环视

语法是(? =…)，要求右边的字符串匹配指定的表达式。比如表达式 abc(? =def)，(? =def) 在字符 c 右面，即匹配 c 右边的边界。对该边界的要求是：它的右边有def，比如 abcdef，如果没有则不匹配，比如 abcd。

否定顺序环视

语法是(? ! …)，要求右边的字符串不能匹配指定的表达式。比如表达式 s(? ! ing)，匹配一般的 s，但不匹配后面有 ing 的 s。注意：避免与排除型字符组混淆，比如 s[^ing]，匹配的是两个字符，第一个是 s，第二个是 i、n、g 以外的任意一个字符。

肯定逆序环视

语法是(? <=…)，要求左边的字符串匹配指定的表达式。比如表达式 (? <=\s)abc，(? <=\s) 在字符 a 左边，即匹配 a 左边的边界。对该边界的要求是：它的左边必须是空白字符。

否定逆序环视

语法是(? <! …)，要求左边的字符串不能匹配指定的表达式。比如表达式 (? <! \w)cat，(? <! \w) 在字符 c 左边，即匹配 c 左边的边界。对该边界的要求是：它的左边不能是单词字符。

环视结构也被称为断言，断言的对象是边界，边界不占用字符，没有宽度，所以也被称为零宽度断言。

顺序环视也可以出现在左边，逆序环视也可以出现在右边。

比如：(? =.*[A-Z])\w+ ，\w+ 匹配多个单词字符，(? =.*[A-Z]) 匹配单词字符的左边界，这是一个肯定顺序环视，对这个左边界的要求是，它右边的字符串匹配表达式 .*[A-Z]，就是说，它右边至少要有一个大写字母。

匹配模式

在正则表达式中，可以指定多个模式。

单行匹配模式

又称点号匹配模式，此模式下，'.' 匹配任意字符，包括换行符。有两种方式指定匹配模式：

一种是在正则表达式中，以 (? s)开头，s 表示 single line，即单行匹配模式，比如：(? s)a.f；

一种是在程序中指定，Java 中对应的模式常量是 Pattern.DOTALL 。

多行匹配模式

在此模式下，会以行为单位进行匹配，^ 匹配的是行开始，$ 匹配的是行结束，比如表达式是 ^abc$，字符串是 “abc\nabc\r\n”，就会有两个匹配。

有两种方式指定匹配模式：

一种是在正则表达式中，以(? m)开头，m表示multi-line，即多行匹配模式；

一种是在程序中指定，Java 中对应的模式常量是 Pattern.MULTILINE。

不区分大小写的模式

一种是在正则表达式开头使用 (? i)， i 为 ignore，比如：(? i)the；

一种在程序中指定，Java 中对应的模式常量是 Pattern.CASE_INSENSITIVE。

Java API

正则表达式相关的类位于包 java.util.regex 下，有两个主要的类，一个是 Pattern，另一个是 Matcher。

Pattern

Pattern 表示正则表达式对象，它与要处理的具体字符串无关。

表示正则表达式

正则表达式由元字符和普通字符组成，在正则表达式中，字符 ‘\’ 是一个元字符，要表示 ‘\’ 本身，需要使用它转义，即 ‘\\’。

在 Java 中，需要用字符串表示正则表达式，而在字符串中，''也是一个元字符，要表示 ‘\’ 本身，需要使用它转义，即 ‘\\’。

为了在字符串中表示正则表达式的 ‘\’ 本身，就需要使用四个 ‘\’ 。字符串表示的正则表达式可以被编译为一个 Pattern 对象。

String regex = "<(\\w+)>(.*)</\\1>";
Pattern pattern = Pattern.compile(regex);

编译有一定的成本，Pattern 对象只与正则表达式有关，与要处理的具体文本无关，可以安全地被多线程共享，应该尽量重用 Pattern 对象，避免重复编译。

Pattern 的 compile 方法接受一个额外参数，可以指定匹配模式，多个模式可以一起使用，通过 ‘|’ 连起来即可。

Pattern.DOTALL 单行模式（点号模式）
Pattern.MULTILINE 多行模式
Pattern.CASE_INSENSI-TIVE 大小写无关模式
Pattern.LITERAL 正则表达式的元字符将失去特殊含义，被看作普通字符，和 Pattern 的静态 quote() 方法作用一样。

切分

String 的 split 将参数 regex 看作正则表达式，而不是普通的字符串，如果分隔符包含元字符，比如 ．$ | ( ) [ { ^ ? * + \，就需要转义。

如果分隔符是用户指定的，程序事先不知道，可以通过 Pattern.quote() 将其看作普通字符串。

分隔符就不一定是一个字符，比如，可以将一个或多个空白字符或点号作为分隔符。

String str = " abc def  hello.\n    world";
String[] fields = str.split("[\\s.]+");
System.out.println(Arrays.toString(fields));

需要说明的是，尾部的空白字符串不会包含在返回的结果数组中，但头部和中间的空白字符串会被包含在内。

String str = ", abc, , def, , ";
String[] fields = str.split(", ");
System.out.println("field num: "+fields.length); // field num: 4
System.out.println(Arrays.toString(fields)); // [, abc, , def]

如果字符串中找不到匹配 regex 的分隔符，返回数组长度为1，元素为原字符串。

Pattern 也有 split 方法，与 String 方法的定义类似：

public String[] split(CharSequence input)

1）Pattern接受的参数是CharSequence，更为通用，String、StringBuilder、StringBuffer、CharBuffer 等都实现了该接口。

2）如果 regex 长度大于 1 或包含元字符，String 的 split 方法必须先将 regex 编译为 Pattern 对象，再调用 Pattern 的 split 方法，为避免重复编译，应该优先采用Pattern 的方法。

3）如果 regex 就是一个字符且不是元字符，String 的 split 方法会采用更为简单高效的实现，这时应该优先采用 String 的 split 方法。

验证

检验输入文本是否完整匹配预定义的正则表达式，经常用于检验用户的输入是否合法。

String 的 matches：

public boolean matches(String regex) {
  return Pattern.matches(regex, this);
}

实际调用的是 Pattern 的 matches ：

public static boolean matches(String regex, CharSequence input) {
  Pattern p = Pattern.compile(regex);
  Matcher m = p.matcher(input);
  return m.matches();
}

Matcher

Matcher 表示一个匹配，它将正则表达式应用于具体字符串，通过它对字符串进行处理。

查找

public static void find(){
  String regex = "\\d{4}-\\d{2}-\\d{2}";
  Pattern pattern = Pattern.compile(regex);
  
  String str = "today is 2017-06-02, yesterday is 2017-06-01";
  Matcher matcher = pattern.matcher(str);
  
  while(matcher.find()){
    System.out.println("find " + matcher.group() 
                       +" position: " + matcher.start() + "-" + matcher.end());
  }
}

Matcher 的内部记录有一个位置，起始为 0，find 方法从这个位置查找匹配正则表达式的子字符串，找到后，返回 true，并更新这个内部位置。

匹配到的子字符串信息可以通过如下方法获取：

// 匹配到的完整子字符串，group() 其实调用的是 group(0)，表示获取匹配的第0个分组的内容，分组0是一个特殊分组，表示匹配的整个子字符串
public String group()
// 子字符串的起始位置
public int start()
// 子字符串的结束位置加 1
public int end()
  
// 分组编号为 group 的内容
public String group(int group)
// 分组编号为 group 的起始位置
public int start(int group)
// 分组编号为 group 的结束位置加 1
public int end(int group)

// group(0) 不统计
public int groupCount()
  
// 分组命名为 name 的内容
public String group(String name)

public static void findGroup() {
  String regex = "(\\d{4})-(\\d{2})-(\\d{2})";
  Pattern pattern = Pattern.compile(regex);
  String str = "today is 2017-06-02, yesterday is 2017-06-01";
  Matcher matcher = pattern.matcher(str);
  while (matcher.find()) {
    System.out.println("year:" + matcher.group(1)
                       + ", month:" + matcher.group(2) + ", day:" + matcher.group(3));
  }
}

替换

String的 replaceAll 和 replaceFirst 调用的其实是 Pattern 和 Matcher 中的方法。

public String replaceAll(String regex, String replacement) {
  return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}

为避免元字符的干扰，可以使用 Matcher 的 quoteReplacement 静态方法将其视为普通字符串。

public static String quoteReplacement(String s)

除了一次性的替换操作外，Matcher 还定义了边查找、边替换的方法。

public Matcher appendReplacement(StringBuffer sb, String replacement)
  
public StringBuffer appendTail(StringBuffer sb)

Pattern pattern = Pattern.compile("cat");
Matcher matcher = pattern.matcher("one cat,two cat,three cat");
StringBuffer sb = new StringBuffer(); // sb 存放最终的替换结果
int foundNum = 0;

while(matcher.find()){
  matcher.appendReplacement(sb,"dog");
  foundNum++;
  if(foundNum == 2) break;
}

matcher.appendTail(sb);
System.out.println(sb.toString());

Matcher 内部除了查找位置，还有一个 append 位置，初始为0，当找到一个匹配的子字符串后，appendReplacement() 做了三件事情：

1）将 append 位置到当前匹配之前的子字符串 append 到 sb 中，在第一次操作中，为 "one "，第二次为 ", two "（注意空格）。

2）将替换字符串 append 到 sb 中。

3）更新 append 位置为当前匹配之后的位置。

appendTail 将 append 位置之后所有的字符 append 到 sb 中。

模板引擎

模板是一个字符串，中间有一些变量，以 {name} 表示。

String template = "Hi {name}, your code is {code}.";

上述模板字符串中有两个变量：一个是 name，另一个是 code。

变量的实际值通过 Map 提供，变量名称对应 Map 中的键，模板引擎的任务就是接受模板和 Map 作为参数，返回替换变量后的字符串。

public class PatternTemplate {

    private static Pattern templatePattern = Pattern.compile("\\{(\\w+)\\}");

    public static String templateEngine(String template, Map<String,Object> params) {
        StringBuffer sb = new StringBuffer();
        // 寻找所有的模板变量，正则表达式为 \{(\w+)\}
        Matcher matcher = templatePattern.matcher(template);
        while(matcher.find()){
            String key = matcher.group(1);
            Object value = params.get(key);
            matcher.appendReplacement(sb,value != null ? Matcher.quoteReplacement(value.toString()) : "");
        }
        matcher.appendTail(sb);
        return sb.toString();
    }


    public static void main(String[] args) {
        String template = "Hi {name},your code is {code}";
      
        Map<String,Object> params = new HashMap<>();
        params.put("name","JOJO");
        params.put("code","6789");
      
        System.out.println(templateEngine(template, params));
    }

}