资源来自菜鸟教程：http://www.runoob.com/regexp/regexp-syntax.html

什么是正则表达式

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

例子：

• runoo+b，可以匹配 runoob、runooob、runoooooob 等，+ 号代表前面的字符必须至少出现一次（1次或多次）。
• runoo*b，可以匹配 runob、runoob、runoooooob 等，* 号代表字符可以不出现，也可以出现一次或者多次（0次、或1次、或多次）。
• colou?r 可以匹配 color 或者 colour，? 问号代表前面的字符最多只可以出现一次（0次、或1次）。

构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。
正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

普通字符

普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

非打印字符

非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：

US-ASCII控制字符

US-ASCII控制字符

特殊字符

所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 *，简单的说就是表示任何字符串的意思。如果要查找字符串中的 * 符号，则需要对 * 进行转义，即在其前加一个 \: runo\*ob 匹配 runo*ob。
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符“\”放在它们前面。下表列出了正则表达式中的特殊字符：

限定符

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。
正则表达式的限定符有：

例：

搜索 HTML 文档，以查找括在 H1 标记内的章节标题。该文本在您的文档中如下：

<H1>1、介绍正则表达式</H1>

则有表达式：

"<.*>"

表达式匹配从开始小于符号 (<) 到关闭 H1 标记的大于符号 (>) 之间的所有内容。

贪婪、非贪婪

*、+限定符都是贪婪的，（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。
比如上面的例子，当我们要匹配开始和结束的 H1 标签时，表达式如下：

"<.*?>"

如果只想匹配开始的 H1 标签，表达式则是：

"<\w+?>"

通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从"贪心"表达式转换为"非贪心"表达式或者最小匹配。

定位符

定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。
定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。
正则表达式的定位符有：

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

选择

用圆括号"(",")"将所有选择项括起来，相邻的选择项之间用|分隔。h(e|is)匹配he、his。
用圆括号会另外一个作用，使相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种缓存作用。
其中 ?: 是非捕获元之一，还有两个非捕获元是 ?= 和 ?!，这两个还有更多的含义，前者为正向预查，在任何，后者为负向预查。

反向引用

对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
可以使用非捕获元字符 ?:、?= 或 ?! 来重写捕获（不理解?=、?!没关系，后面还会提及），忽略对相关匹配的保存。
反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。以下面的句子为例：

Is is the cost of of gasoline going up up?

\b([a-z]+) \1\b

这里是个js实例：

var str = "Is is the cost of of gasoline going up up";
var patt1 = /\b([a-z]+) \1\b/ig;
document.write(str.match(patt1));

这里的\1表示的就是第一个小括号的表达式匹配缓存，/ig表示的是忽略大小写且全局匹配（/i 不区分大小写 insensitive；/g 全局匹配 global；/m 多行模式 multi。这里对应了java的Pattern.compile(String regex, int flag)flag参数，后面会有写到），匹配结果为：

Is is,of of,up up

反向引用还可以将通用资源指示符 (URI) 分解为其组件。假定您想将下面的 URI 分解为协议（ftp、http 等等）、域地址和页/路径：

例子

var str = "http://www.runoob.com:80/html/html-tutorial.html";
var patt1 = /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/;
arr = str.match(patt1);
for (var i = 0; i < arr.length ; i++) {
    document.write(arr[i]);
    document.write("<br>");
}

第三行代码 str.match(patt1) 返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。
第一个括号子表达式捕获 Web 地址的协议部分（\w 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。）。该子表达式匹配在冒号和两个正斜杠前面的任何单词。
第二个括号子表达式捕获地址的域地址部分。子表达式匹配 : 和 / 之后的一个或多个字符。
第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。
最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 # 或空格字符的任何字符序列。
将正则表达式应用到上面的 URI，各子匹配项包含下面的内容：

• 第一个括号子表达式包含 http
• 第二个括号子表达式包含 www.runoob.com
• 第三个括号子表达式包含 :80
• 第四个括号子表达式包含 /html/html-tutorial.html

剩余的元字符

运算符优先级

正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式非常类似。
相同优先级的从左到右进行运算，不同优先级的运算先高后低。下表从最高到最低说明了各种正则表达式运算符的优先级顺序：

Java 正则表达式

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

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

实例

import java.util.regex.*;
 
class RegexExample1{
   public static void main(String args[]){
      String content = "I am noob " +
        "from runoob.com.";
 
      String pattern = ".*runoob.*";
 
      boolean isMatch = Pattern.matches(pattern, content);
      System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
   }
}

结果：

字符串中是否包含了 'runoob' 子字符串? true

捕获组
捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。
例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，"o"，和"g"。
捕获组是通过从左至右计算其开括号来编号。例如，在表达式((A)(B(C)))，有四个这样的组：
((A)(B(C)))
(A)
(B(C))
(C)
可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。
还有一个特殊的组（group(0)），它代表整个表达式。在 groupCount 的返回值中不包括该组。

例如

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    public static void main( String args[] ){
 
      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(\\D*)(\\d+)(.*)";
 
      // 创建 Pattern 对象
      Pattern r = Pattern.compile(pattern);
 
      // 现在创建 matcher 对象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
         System.out.println("Found value: " + m.group(3) ); 
      } else {
         System.out.println("NO MATCH");
      }
   }
}

运行结果：

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?

反斜杠 \ 在 Java 中表示转义字符，这意味着 \ 在 Java 拥有预定义的含义。

• 在匹配 . 或 { 或 [ 或 ( 或 ? 或 $ 或 ^ 或 * 这些特殊字符时，需要在前面加上 \\，比如匹配 . 时，Java 中要写为\\.，但对于正则表达式来说就是 \.。
• 在匹配 \ 时，Java 中要写为 \\，但对于正则表达式来说就是 \\。
• 例如要匹配中文的时候，要使用"[\\u4e00-\\u9fa5]+"(4e00-9fa5为中文字符的Unicode编码范围)

API

Pattern
Pattern.matches()
检查一个正则表达式的模式是否匹配一段文本的最直接方法是调用静态方法,Pattern.matches()方法适用于检查一个模式在一个文本中出现一次的情况
如果需要匹配多次出现,甚至输出不同的匹配文本。需要通过Pattern.compile()方法得到一个Pattern实例。

public static Pattern compile(String regex, int flags)

• Pattern.CANON_EQ，当且仅当两个字符的”正规分解(canonical decomposition)”都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式”a\u030A”会匹配”?”。一般，字符串是根据规范等价(canonically equivalent)来进行相等判断的。即使两个规范等价的字符串的底层Unicode标量不一样，只要他们的语义跟表现形式是一致的，他们就被认为是相等的。

规范相等性(canonical equivalence)是Unicode字符集编码中的一个规范，简单来说就是两个不同的code point表示同一个字符

代码点(code point)是字符集被编码后出现的概念。字符集（Code Set）是一个集合，集合中的元素就是字符，比如ASCII字符集，其中的字符就是'A'、'B'等字符。为了在计算机中处理字符集，必须把字符集数字化，就是给字符集中的每一个字符一个编号，计算机程序中要用字符，直接用这个编号就可以了。于是就出现了编码后的字符集，叫做编码字符集(Coded Code Set)。编码字符集中每一个字符都和一个编号对应。那么这个编号就是代码点（Code Point）。

• Pattern.CASE_INSENSITIVE(?i) 默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配，只要将UNICODE_CASE与这个标志合起来就行了。
• Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(不是指表达式里的”\s”，而是指表达式里的空格，tab，回车之类)。忽略用#开始的注释，一直到这行结束。
• Pattern.DOTALL(?s) 在这种模式下，表达式’.’可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式’.’不匹配行的结束符。
• Pattern.MULTILINE(?m)在这种模式下，’^’和“$”分别匹配一行的开始和结束。此外，’^’仍然匹配字符串的开始，’$’也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。
• Pattern.UNICODE_CASE(?u) 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。
• Pattern.UNIX_LINES(?d) 在这个模式下，只有’\n’才被认作一行的中止，并且与’.’，’^’，以及’$’进行匹配。
• Pattern.LITERAL，当指定此标志时，指定模式的输入字符串将被视为字面字符序列。输入序列中的元字符或转义序列将没有特殊含义。只有CASE_INSENSITIVE 和 UNICODE_CASE跟这个flag一块使用时，保留他们的规则，由于所有元字符和转移字符都当成字面字符被看待，所以其他flag没有作用。
• Pattern.UNICODE_CHARACTER_CLASS 使用Unicode中的预定义字符集（\d、\w）。由于安卓默认支持Unicode预定义字符集，所以这个标志对android没有影响。

Pattern.matcher()
一旦获得了Pattern对象，接着可以获得Matcher对象。Matcher 示例用于匹配文本中的模式.示例如下

Matcher matcher = pattern.matcher(text);

String text = "This is the text to be searched " + "for occurrences of the http:// pattern.";
String patternString = ".*http://.*";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);//忽略大小写
Matcher matcher = pattern.matcher(text);
boolean matches = matcher.matches();
System.out.println("matches = " + matches);

Matcher
通过Pattern 的matcher() 方法可以创建一个Matcher。

Matcher 类的 matches() 方法用于在文本中匹配正则表达式
boolean matches = matcher.matches();

lookingAt()
lookingAt() 与matches() 方法类似，最大的不同是，lookingAt()方法对文本的开头匹配正则表达式；而matches() 对整个文本匹配正则表达式。换句话说，如果正则表达式匹配文本开头而不匹配整个文本,lookingAt() 返回true,而matches() 返回false。 示例：

String text = "This is the text to be searched " + "for occurrences of the http:// pattern.";
String patternString = "This is the";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(text);
System.out.println("lookingAt = " + matcher.lookingAt());
System.out.println("matches = " + matcher.matches());

上面的例子分别对文本开头和整个文本匹配正则表达式 “this is the”. 匹配文本开头的方法(lookingAt()) 返回true。对整个文本匹配正则表达式的方法 (matches()) 返回false，因为整个文本包含多余的字符,而 正则表达式要求文本精确匹配”this is the”,前后又不能有额外字符。

find() + start() + end()
find() 方法用于在文本中查找出现的正则表达式，文本是创建Matcher时，通过 Pattern.matcher(text) 方法传入的。如果在文本中多次匹配，find() 方法返回第一个，之后每次调用 find() 都会返回下一个。
start() 和 end() 返回每次匹配的字串在整个文本中的开始和结束位置。实际上, end() 返回的是字符串末尾的后一位，这样，可以在把 start() 和 end() 的返回值直接用在String.substring() 里。

String text = "This is the text which is to be searched " + "for occurrences of the word 'is'.";
String patternString = "is";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);
int count = 0;
while(matcher.find()) {
    count++;
    System.out.println("found: " + count + " : "  + matcher.start() + " - " + matcher.end());
}

结果：

found: 1 : 2 - 4
found: 2 : 5 - 7
found: 3 : 23 - 25
found: 4 : 70 - 72

reset()
reset() 方法会重置Matcher 内部的 匹配状态。当find() 方法开始匹配时,Matcher 内部会记录截至当前查找的距离。调用 reset() 会重新从文本开头查找。
也可以调用 reset(CharSequence) 方法. 这个方法重置Matcher,同时把一个新的字符串作为参数传入，用于代替创建 Matcher 的原始字符串。
group()
前面说到，我们可以利用find()方法找到匹配，并可以利用start()、end()拿到匹配的字符。
还要一种简单的用法，就是group()。使用group(int groupNo) 方法访问一个分组。
group(0);始终返回整个正则表达式，且不会再groupCount()中记录。

int count = 0;
String text = "is a is b";
String patternStr = "(is) ([a-z])";
Pattern pattern = Pattern.compile(patternStr);
Matcher matcher = pattern.matcher(text);
while (matcher.find()){
    count++;
    for (int i = 0; i <= matcher.groupCount(); i++) {
        System.out.println("find #"+count+":group"+i+" "+matcher.group(i));
    }
}

结果：

find #1:group0 is a
find #1:group1 is
find #1:group2 a
find #2:group0 is b
find #2:group1 is
find #2:group2 b

嵌套分组

((John) (.+?))

当遇到嵌套分组时, 分组编号是由左括号的顺序确定的。上例中，分组1 是那个大分组。分组2 是包括John的分组，分组3 是包括 .+? 的分组。

上例正则表达式最外层加上小括号

"((is) ([a-z]))"

运行结果为：

find #1:group0 is a
find #1:group1 is a
find #1:group2 is
find #1:group3 a
find #2:group0 is b
find #2:group1 is b
find #2:group2 is
find #2:group3 b

正则表达式((A)(B(C)))则对应的分组为：

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

replaceAll() + replaceFirst()
replaceAll() 和 replaceFirst() 方法可以用于替换Matcher搜索字符串中的一部分。replaceAll() 方法替换全部匹配的正则表达式，replaceFirst() 只替换第一个匹配的。
还有一点就是：在处理之前，Matcher 会先重置。所以这里的匹配表达式从文本开头开始计算。

String text = "John writes about this, and John Doe writes about that,"
                   + " and John Wayne writes about everything.";
String patternString1 = "((John) (.+?)) ";
Pattern pattern = Pattern.compile(patternString1);
Matcher matcher = pattern.matcher(text);
String replaceAll = matcher.replaceAll("Joe Blocks ");
System.out.println("replaceAll   = " + replaceAll);
String replaceFirst = matcher.replaceFirst("Joe Blocks ");
System.out.println("replaceFirst = " + replaceFirst);

replaceAll = Joe Blocks about this, and Joe Blocks writes about that,and Joe Blocks writes about everything.
replaceFirst = Joe Blocks about this, and John Doe writes about that,and John Wayne writes about everything.

appendReplacement() + appendTail()
appendReplacement() 和 appendTail() 方法用于替换输入文本中的字符串短语，并把替换后的字符串附加到一个StringBuffer中，我们可以从StringBuffer拿到替换后的字符串。
appendReplacement()方法可以替换文本中的数据，并且把上一次匹配的结束位置到替换字符的结束附加到StringBuffer中。
当匹配结束，文本的末尾可能还有一部分没有匹配到的文本，可以使用appendTail()把剩余没有匹配到的字段附加到StringBuffer。

String text =  "John writes about this, and John Doe writes about that," +
                  " and John Wayne writes about everything.";
String patternString1 = "((John) (.+?)) ";
Pattern pattern = Pattern.compile(patternString1);
Matcher matcher = pattern.matcher(text);
StringBuffer stringBuffer = new StringBuffer();
while(matcher.find()){
    matcher.appendReplacement(stringBuffer, "Joe Blocks "); 
    System.out.println(stringBuffer.toString());
}
matcher.appendTail(stringBuffer);//把剩余的“writes about everything.”添加到末尾
System.out.println(stringBuffer.toString());

Joe Blocks
Joe Blocks about this, and Joe Blocks
Joe Blocks about this, and Joe Blocks writes about that, and Joe Blocks
Joe Blocks about this, and Joe Blocks writes about that, and Joe Blocks writes about everything.

同时appendReplacement方法的第二个参数还可以通过设置"$n"(n的范围是'0'-'9')和"${groupName}"(groupName是在正则表达式中定义的组名，"(?<groupName>pattern)")，来获取正则表达式中的group。api代码实现如下：

public Matcher appendReplacement(StringBuffer sb, String replacement) {
        sb.append(input.substring(appendPos, start()));//添加从上次匹配结束位置--当前匹配开始位置截取的字符
        appendEvaluated(sb, replacement);//添加要替换的文本
        appendPos = end();//更新游标

        return this;
    }
... ...
private void appendEvaluated(StringBuffer buffer, String s) {
        boolean escape = false;
        boolean dollar = false;
        boolean escapeNamedGroup = false;
        int escapeNamedGroupStart = -1;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '\\' && !escape) {
                escape = true;
            } else if (c == '$' && !escape) {
                dollar = true;
            } else if (c >= '0' && c <= '9' && dollar) {//上个字符为\$则匹配group0-group9
                buffer.append(group(c - '0'));
                dollar = false;
            } else if (c == '{' && dollar) {//${groupName}
                escapeNamedGroup = true;
                escapeNamedGroupStart = i;
            } else if (c == '}' && dollar && escapeNamedGroup) {
                String namedGroupName =
                    s.substring(escapeNamedGroupStart + 1, i);
                buffer.append(group(namedGroupName));//${groupName}
                dollar = false;
                escapeNamedGroup = false;
            } else if (c != '}' && dollar && escapeNamedGroup) {
                continue;
            } else {
                buffer.append(c);
                dollar = false;
                escape = false;
                escapeNamedGroup = false;
            }
        }

改变上一个例字为：

String text =  "John writes about this, and John Doe writes about that," +
                " and John Wayne writes about everything.";
        String patternString1 = "((?<group1>John) (.+?)) ";
        Pattern pattern = Pattern.compile(patternString1);
        Matcher matcher = pattern.matcher(text);
        StringBuffer stringBuffer = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(stringBuffer, "Joe ${group1} $3 ");
            System.out.println(stringBuffer.toString());
        }
        matcher.appendTail(stringBuffer);//把剩余的“writes about everything.”添加到末尾
        System.out.println(stringBuffer.toString());

新的输出结果为：

Joe John writes
Joe John writes about this, and Joe John Doe
Joe John writes about this, and Joe John Doe writes about that, and Joe John Wayne
Joe John writes about this, and Joe John Doe writes about that, and Joe John Wayne writes about everything.

over~~~~