正则表达式

什么是正则表达式？

正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表通常被用来检索、替换那些符合某个模式(规则)的文本。

元字符

字符 描述 \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，’n’ 匹配字符 “n”。’\n’ 匹配一个换行符。序列 ‘\’ 匹配 “\” 而 “(” 则匹配 “(“。 ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。 $ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，也匹配 ‘\n’ 或 ‘\r’ 之前的位置。 * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。 + 匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。 ? 匹配前面的子表达式零次或一次。例如，”do(es)?” 可以匹配 “do” 或 “does” 中的”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?’。请注意在逗号和两个数之间不能有空格。 ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo”，’o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。 . 匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用像”(.|\n)”的模式。 (pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 0…9 属性。要匹配圆括号字符，请使用 ‘(’ 或 ‘)’。 (?:pattern) 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如， ‘industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式。 (?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，’Windows (?=95|98|NT|2000)’ 能匹配 “Windows 2000” 中的 “Windows” ，但不能匹配 “Windows 3.1” 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 (?!pattern) 负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’ 能匹配 “Windows 3.1” 中的 “Windows”，但不能匹配 “Windows 2000” 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 x|y 匹配 x 或 y。例如，’z|food’ 能匹配 “z” 或 “food”。’(z|f)ood’ 则匹配 “zood” 或 “food”。 [xyz] 字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。 [^xyz] 负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p’、’l’、’i’、’n’。 [a-z] 字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。 [^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。 \b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。 \B 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。 \cx 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。 \d 匹配一个数字字符。等价于 [0-9]。 \D 匹配一个非数字字符。等价于 [^0-9]。 \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。 \w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。 \W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。 \xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 “A”。’\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。 \num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’ 匹配两个连续的相同字符。 \n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。 \nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。 \nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。 \un 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

更详细的正则教程

Java 中的正则表达式

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

• Pattern 类：Pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共的构造方法，要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一下正则表达式作为它的第一个参数。
• Matcher 类：Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与 Pattern 类一样，Matcher 也没有公共的构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
• PatternSyntaxException 异常：PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

Pattern

Pattern.matches()

检查正则表达式模式是否匹配文本的最简单方法是使用 Pattern.matches() 静态方法：

public static void m1() {    String text = "这是一个文本字符串";    String pattern = ".*文本.*";    boolean matches = Pattern.matches(pattern, text);    System.out.println("matches = " + matches);    // 输出 matches = true}

如果你只需要对一个文本进行一次检查时，并且 Pattern 的默认设置又符合你的要求，该方法将是你的最佳选择。

Pattern.compile()

如果需要多次匹配文本与正则表达式模式时，则需要使用 Pattern.compile() 方法创建一个实例：

public static void m2() {    Pattern p = Pattern.compile("a*b");}

你也可以使用 Pattern.compile() 方法的第二个参数编译有特殊标志的 Pattern。

    Pattern p = Pattern.compile("a*b", Pattern.CASE_INSENSITIVE);

Pattern 类包含一些可用于使 Pattern 匹配行为以某些方式使用的标志（int 常量）列表。上面使用的标志使得模式匹配时忽略文本大小写。

Pattern.matcher()

获取 Pattern 实例后，可以使用 matcher() 实例方法获取 Matcher 实例：

Pattern p = Pattern.compile("a*b");Matcher m = p.matcher("aaaaab");

我们可以通过 Matcher 的实例以各种方式访问文本的匹配部分。

Pattern.split()

split 可以使用正则表达式将文本分割为 string数组：

public static void m3() {    String text = "A sep Text sep with sep many sep Separators";    String patternString = "sep";    Pattern pattern = Pattern.compile(patternString);    String[] split = pattern.split(text);    System.out.println("split.length =" + split.length);    for (String element : split) {        System.out.println("element =" + element);    }    // 输出：    // split.length =5    // element =A     // element = Text     // element = with     // element = many     // element = Separators}

与分隔符匹配的文本部分不包括在返回的String数组中。

Pattern.pattern()

Pattern.pattern()方法返回 Pattern 实例被编译的模式字符串（正则表达式）：

public static void m4() {    Pattern pattern = Pattern.compile("a*b");    String patternStr = pattern.pattern();    System.out.println(pattern);    System.out.println(patternStr);    // 输出：    // a*b    // a*b}

其实Pattern 实例的toString()方法和pattern()方法都返回的是正则表达式。

Matcher

Matcher没有公共的构造方法，我们需要调用 Pattern 对象的 public Matcher matcher(CharSequence input) 方法来获得一个 Matcher 实例。

matches()

我们可以调用 Matcher 的实例方法 matches() 来判断文本是否与正则表达式匹配：

public static void m5() {    Pattern p = Pattern.compile("a*b");    Matcher m = p.matcher("aaaaab");    boolean b = m.matches();    System.out.println(b);    // 输出 true}

如果正则表达式与整个文本匹配则返回true，反之 false。

lookingAt()

matches 和 lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是 matcher 要求整个序列都匹配，而lookingAt 不要求。lookingAt 方法虽然不需要整句都匹配，但是需要从第一个字符开始匹配。换句话说就是，如果正则表达式与文本的开头匹配，而不是整个文本，lookingAt() 则返回true,而 matches() 返回 false。

public static void m6() {    String str1 = "abbbbbbbbbb";    String str2 = "cabbbbbb";    Pattern p = Pattern.compile("abbb");    Matcher m1 = p.matcher(str1);    Matcher m2 = p.matcher(str2);    System.out.println(m1.matches());    System.out.println(m1.lookingAt());    System.out.println(m2.lookingAt() );    // 输出    // false    // true    // false}

find() + start() + end()

find() 方法从匹配器区域的开头开始，如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始。如果匹配成功，则可以通过 start、end 和 group 方法获取更多信息。
start() 返回以前匹配的初始索引, end() 返回最后匹配字符之后的偏移量。

public static void m7() {    String str = "test  test testa ttt";    Pattern p = Pattern.compile("test");    Matcher m = p.matcher(str);    int count = 0;    while (m.find()) {        System.out.println(String.format("found: %s - %s - %s", ++count, m.start(), m.end()));    }    // 输出    // found: 1 - 0 - 4    // found: 2 - 6 - 10    // found: 3 - 11 - 15}

reset()

该Matcher reset()方法在内部重置匹配状态Matcher。如果您通过该find()方法已经开始匹配字符串中的匹配事件，Matcher则内部将会保留关于通过输入文本搜索的距离的状态。通过调用reset()匹配将从文本的开头再次开始。
还有一种reset(CharSequence)方法。此方法将重置Matcher，并使得Matcher通过字符序列参数进行搜索，而不是Matcher创建时的字符序列了。

group()

public static void m9() {    String str = "test  test testa ttt";    Pattern p = Pattern.compile("(test)");    Matcher m = p.matcher(str);    while (m.find()) {        System.out.println(String.format("found: %s", m.group(1)));    }    // 输出    // found: test    // found: test    // found: test}

Multiple Groups

public static void m10() {    String str = "test ab test cd testa ef ttt";    Pattern p = Pattern.compile("(test) (.+?) ");    Matcher m = p.matcher(str);    while (m.find()) {        System.out.println(String.format("found: %s - %s", m.group(1), m.group(2)));    }    // 输出    // found: test - ab    // found: test - cd}

Groups Inside Groups

public static void m11() {    String str = "test ab test cd testa ef ttt";    Pattern p = Pattern.compile("((test) (.+?)) ");    Matcher m = p.matcher(str);    while (m.find()) {        System.out.println(String.format("found: %s - %s - %s", m.group(1), m.group(2), m.group(3)));    }    // 输出    // found: test ab - test - ab    // found: test cd - test - cd}

replaceAll() + replaceFirst()

public static void m12() {    String str = "test ab test cd testa ef ttt";    Pattern p = Pattern.compile("((test) (.+?)) ");    Matcher m = p.matcher(str);    String replaceAll = m.replaceAll("ha ");    System.out.println(replaceAll);    String replaceFirst = m.replaceFirst("xi ");    System.out.println(replaceFirst);    // 输出    // ha ha testa ef ttt    // xi test cd testa ef ttt}

appendReplacement() + appendTail()

public static void m13() {    String text = "test aaa test bbb test ccc dddd";    Pattern p = Pattern.compile("((test) (.+?)) ");    Matcher m = p.matcher(text);    StringBuffer stringBuffer = new StringBuffer();    while (m.find()) {        m.appendReplacement(stringBuffer, "ha ");        System.out.println(stringBuffer.toString());    }    m.appendTail(stringBuffer);    System.out.println(stringBuffer.toString());    // 输出    // ha     // ha ha     // ha ha ha     // ha ha ha dddd}