Java-正则表达式

元字符概念以及元字符的反义

  正则表达式中的几种重复模式

分枝条件

用 | 把不同的规则分割开

从左到右地测试每个条件，如果满足了某个分枝的话，就不会去再管其它的条件了

0\d{2}-\d{8}|0\d{3}-\d{7}

 

字符类

[0-9] == \d

[a-z0-9A-Z] == \w

[&?.]

[aeiou]

例子：

(012)12345678
012-12345678
^[\s(]?\d{2,3}[\s)-]\d{7,8}]$

 

分组

　　将子表达式进行做成子集

　　使用()分组

　　方便对match的字符串进行划分

　　(\d{1,3}\.){3}\d{1,3}（IP地址）

　　分组的 命名：(?<groupname>exp)

　　(?:exp)匹配exp，不捕获匹配的文本，也不给此分组组号

贪婪与懒惰

贪婪（尽可能多）

a.*b(aabab)-->aabab

懒惰（尽可能少）

a.*？b(aabab)-->aab  ab

a.+？b(aabab)-->aab

 处理选项

正则表达式在Java中的应用

正则表达式语法

在其他语言中，\\ 表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。

在 Java 中，\\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。

所以，在其他的语言中（如Perl），一个反斜杠 \ 就足以具有转义的作用，而在 Java 中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在 Java 的正则表达式中，两个 \\ 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 \\d，而表示一个普通的反斜杠是 \\\\。

 

java.util.regex 包主要包括以下三个类：

• Pattern 类：

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

• Matcher 类：

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

• PatternSyntaxException：

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

 Matcher 类的方法

 索引方法

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

start 和 end

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class StartAndEnd {
    public static void main(String[] args) {
        String input = "    regular is very important,remember regularexpressions,regular! regular! regular!";
        String regex = "\\bregular\\b";
        Pattern pattern = Pattern.compile(regex);
        Matcher m = pattern.matcher(input);
        while(m.find()) {
            System.out.println("startIndex:"+m.start());
            System.out.println("endIndex:"+m.end());
        }
    }
}

查找方法

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

 

looking() 和 matchers()

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

public class LookingAndMathers {

    public static void main(String[] args) {
        String input = "regular is very important,remember regularexpressions,regular! regular! regular!";
        String input2 = "regular";
        String regex = "regular";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher m = pattern.matcher(input);
        Matcher m2 = pattern.matcher(input2);
        
        System.out.println(m.lookingAt()+"---"+m.group());//lookingAt 方法虽然不需要整句都匹配，但是需要从第一个字符开始匹配。
        System.out.println(m.matches());//需要整句都匹配
        
        System.out.println(m2.matches()+"---"+m2.group());//需要整句匹配
    }
}

替换方法

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

replaceFirst() 和replaceAll(),replaceFirst 替换首次匹配，replaceAll 替换所有匹配。

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

public class Replace {

    public static void main(String[] args) {
        String input = "dog is an animal,dog is cute";
        String input2 = "dog is an animal,dog is cute";
        String regex = "dog";
        String replace = "cat";
        
        Pattern pattern = Pattern.compile(regex);
        Matcher m = pattern.matcher(input);
        Matcher m2 = pattern.matcher(input2);
        
        input = m.replaceFirst(replace);
        System.out.println(input);
        input2 = m2.replaceAll(replace);
        System.out.println(input2);
    }

}

反向引用

\b(\w+)\s+(\1)\s+或者\b(?<word>\w+)\b\s+\k<word>\b

(\1)是指前面的\w+单词，?<word>是给\w+定义了一个名字为word,\k<word>就是\w+,(\1)相当于\k<word>

 

 零宽断言

挑出单独的数字(?<=\s+)\d(?=\s+)|(?<=\s+)\d(?!\d+)|(?<!\d+)\d(?=\s+)

(?<=\s+)\d(?=\s+)：前后都是空格

(?<=\s+)\d(?!\d+)：前面是空格 后面不是数字

(?<!\d+)\d(?=\s+)：前面不是数字，后面是空格