Java正则表达式

Java正则表达式的解释说明
表达式意义：

1.字符

x    字符 x。例如a表示字符a
\\    反斜线字符。在书写时要写为\\\\。（注意：因为java在第一次解析时,把\\\\解析成正则表达式\\，在第二次解析时再解析为\，所以凡是不是1.1列举到的转义字符，包括1.1的\\,而又带有\的都要写两次）
\0n    带有八进制值 0的字符 n (0 <= n <= 7)
\0nn    带有八进制值 0的字符 nn (0 <= n <= 7)
\0mnn    带有八进制值 0的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh    带有十六进制值 0x的字符 hh
\uhhhh    带有十六进制值 0x的字符 hhhh
\t    制表符 ('\u0009')
\n    新行（换行）符 ('\u000A')
\r    回车符 ('\u000D')
\f    换页符 ('\u000C')
\a    报警 (bell) 符 ('\u0007')
\e    转义符 ('\u001B')
\cx    对应于 x 的控制符
2.字符类
[abc]    a、b或 c（简单类）。例如[egd]表示包含有字符e、g或d。
[^abc]    任何字符，除了 a、b或 c（否定）。例如[^egd]表示不包含字符e、g或d。
[a-zA-Z]    a到 z或 A到 Z，两头的字母包括在内（范围）
[a-d[m-p]]    a到 d或 m到 p：[a-dm-p]（并集）
[a-z&&[def]]    d、e或 f（交集）
[a-z&&[^bc]]    a到 z，除了 b和 c：[ad-z]（减去）
[a-z&&[^m-p]]    a到 z，而非 m到 p：[a-lq-z]（减去）
3.预定义字符类(注意反斜杠要写两次，例如\d写为\\d)任何字符

（与行结束符可能匹配也可能不匹配）
\d    数字：[0-9]
\D    非数字： [^0-9]
\s    空白字符：[ \t\n\x0B\f\r]
\S    非空白字符：[^\s]
\w    单词字符：[a-zA-Z_0-9]
\W    非单词字符：[^\w]
4.POSIX 字符类（仅 US-ASCII)(注意反斜杠要写两次，例如\p{Lower}写为\\p{Lower})
\p{Lower}    小写字母字符：[a-z]。
\p{Upper}    大写字母字符：[A-Z]
\p{ASCII}    所有 ASCII：[\x00-\x7F]
\p{Alpha}    字母字符：[\p{Lower}\p{Upper}]
\p{Digit}    十进制数字：[0-9]
\p{Alnum}    字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}    标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}    可见字符：[\p{Alnum}\p{Punct}]
\p{Print}    可打印字符：[\p{Graph}\x20]
\p{Blank}    空格或制表符：[ \t]
\p{Cntrl}    控制字符：[\x00-\x1F\x7F]
\p{XDigit}    十六进制数字：[0-9a-fA-F]
\p{Space}    空白字符：[ \t\n\x0B\f\r]
5.java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase}    等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase}    等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace}    等效于 java.lang.Character.isWhitespace()
\p{javaMirrored}    等效于 java.lang.Character.isMirrored()
6.Unicode 块和类别的类
\p{InGreek}    Greek 块（简单块）中的字符
\p{Lu}    大写字母（简单类别）
\p{Sc}    货币符号
\P{InGreek}    所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]]     所有字母，大写字母除外（减去）
7.边界匹配器
^    行的开头，请在正则表达式的开始处使用^。例如：^(abc)表示以abc开头的字符串。注意编译的时候要设置参数MULTILINE，如 Pattern p = Pattern.compile(regex,Pattern.MULTILINE);
$    行的结尾，请在正则表达式的结束处使用。例如：(^bca).*(abc$)表示以bca开头以abc结尾的行。
\b    单词边界。例如\b(abc)表示单词的开始或结束包含有abc,（abcjj、jjabc 都可以匹配）
\B    非单词边界。例如\B(abc)表示单词的中间包含有abc,(jjabcjj匹配而jjabc、abcjj不匹配)
\A    输入的开头
\G    上一个匹配的结尾(个人感觉这个参数没什么用)。例如\\Gdog表示在上一个匹配结尾处查找dog如果没有的话则从开头查找,注意如果开头不是dog则不能匹配。
\Z    输入的结尾，仅用于最后的结束符（如果有的话）
行结束符 是一个或两个字符的序列，标记输入字符序列的行结尾。
以下代码被识别为行结束符：
‐新行（换行）符 ('\n')、
‐后面紧跟新行符的回车符 ("\r\n")、
‐单独的回车符 ('\r')、
‐下一行字符 ('\u0085')、
‐行分隔符 ('\u2028') 或
‐段落分隔符 ('\u2029)。
\z    输入的结尾
当编译模式时，可以设置一个或多个标志，例如
Pattern pattern = Pattern.compile(patternString,Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
下面六个标志都是支持的：
‐CASE_INSENSITIVE：匹配字符时与大小写无关，该标志默认只考虑US ASCII字符。
‐UNICODE_CASE：当与CASE_INSENSITIVE结合时，使用Unicode字母匹配
‐MULTILINE：^和$匹配一行的开始和结尾，而不是整个输入
‐UNIX_LINES： 当在多行模式下匹配^和$时，只将'\n'看作行终止符
‐DOTALL: 当使用此标志时，.符号匹配包括行终止符在内的所有字符
‐CANON_EQ: 考虑Unicode字符的规范等价
8.Greedy 数量词
X?    X，一次或一次也没有
X*    X，零次或多次
X+    X，一次或多次
X{n}    X，恰好 n 次
X{n,}    X，至少 n 次
X{n,m}    X，至少 n 次，但是不超过 m 次
9.Reluctant 数量词
X??    X，一次或一次也没有
X*?    X，零次或多次
X+?    X，一次或多次
X{n}?    X，恰好 n 次
X{n,}?    X，至少 n 次
X{n,m}?    X，至少 n 次，但是不超过 m 次
10.Possessive 数量词
X?+    X，一次或一次也没有
X*+    X，零次或多次
X++    X，一次或多次
X{n}+    X，恰好 n 次
X{n,}+    X，至少 n 次
X{n,m}+    X，至少 n 次，但是不超过 m 次
Greedy，Reluctant，Possessive的区别在于:(注意仅限于进行.等模糊处理时)
greedy量 词被看作“贪婪的”，因为它第一次就读入整个被模糊匹配的字符串。如果第一个匹配尝试（整个输入字符串）失败，匹配器就会在被匹配字符串中的最后一位后退一个字符并且再次尝试，重复这个过程，直到找到匹配或者没有更多剩下的字符可以后退为止。根据表达式中使用的量词，它最后试图匹配的内容是1 个或者0个字符。
但是，reluctant量词采取相反的方式：它们从被匹配字符串的开头开始，然后逐步地一次读取一个字符搜索匹配。它们最后试图匹配的内容是整个输入字符串。
最后，possessive量词总是读完整个输入字符串，尝试一次（而且只有一次）匹配。和greedy量词不同，possessive从不后退。
11.Logical 运算符
XY    X 后跟 Y
X|Y    X 或 Y
(X)    X，作为捕获组。例如(abc)表示把abc作为一个整体进行捕获
12.Back 引用
\n    任何匹配的 nth捕获组
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：
1        ((A)(B(C)))
2        \A
3        (B(C))
4        (C)
在表达式中可以通过\n来对相应的组进行引用，例如(ab)34\1就表示ab34ab，(ab)34(cd)\1\2就表示ab34cdabcd。
13.引用
\    Nothing，但是引用以下字符
\Q    Nothing，但是引用所有字符，直到 \E。QE之间的字符串会原封不动的使用(1.1中转义字符的除外)。例如, ab\\Q{|}\\\\E
可以匹配ab{|}\\
\E    Nothing，但是结束从 \Q开始的引用
14.特殊构造（非捕获）
(?:X)    X，作为非捕获组
(?idmsux-idmsux)     Nothing，但是将匹配标志由 on 转为 off。比如：表达式 (?i)abc(?-i)def 这时，(?i) 打开不区分大小写开关，abc 匹配
idmsux说明如下：
‐i CASE_INSENSITIVE :US-ASCII 字符集不区分大小写。(?i)
‐d UNIX_LINES : 打开UNIX换行符
‐m MULTILINE :多行模式(?m)
UNIX下换行为\n
WINDOWS下换行为\r\n(?s)
‐u UNICODE_CASE : Unicode 不区分大小写。(?u)
‐x COMMENTS :可以在pattern里面使用注解，忽略pattern里面的whitespace，以及"#"一直到结尾（#后面为注解）。(?x)例如(?x)abc#asfsdadsa可以匹配字符串abc
(?idmsux-idmsux:X)     X，作为带有给定标志 on - off 的非捕获组。与上面的类似，上面的表达式，可以改写成为：(?i:abc)def，或者 (?i)abc(?-i:def)
(?=X)    X，通过零宽度的正 lookahead。零宽度正先行断言，仅当子表达式 X 在 此位置的右侧匹配时才继续匹配。例如，\w+(?=\d) 表示字母后面跟数字，但不捕获数字（不回溯）
(?!X)    X，通过零宽度的负 lookahead。零宽度负先行断言。仅当子表达式 X 不在 此位置的右侧匹配时才继续匹配。例如，\w+(?!\d) 表示字母后面不跟数字，且不捕获数字。
(?<=X)    X，通过零宽度的正 lookbehind。零宽度正后发断言。仅当子表达式 X 在 此位置的左侧匹配时才继续匹配。例如，(?<=19)99 表示99前面是数字19，但不捕获前面的19。（不回溯）
(? (?>X)    X，作为独立的非捕获组（不回溯）
(?=X)与(?>X)的区别在于(?>X)是不回溯的。例如被匹配的字符串为abcm
当表达式为a(?:b|bc)m是可以匹配的，而当表达式是a(?>b|bc)时是不能匹配的，因为当后者匹配到b时，由于已经匹配，就跳出了非捕获组，而不再次对组内的字符进行匹配。可以加快速度。

 

 

 

 

正则表达式在处理文本方面用处非常大，最早像在Perl和awk语言中，提供了这种机制，Java在Java 2中也增加了正则表达式这个包java.util.regex。这个包为用户使用正则表达式，提供了易用而全面的支持。我的研究方向是web挖掘。从网页中提取内容,处理文本，当然需要正则表达式这个强大的工具了。
一、首先我们看一下怎么使用正则表达式的一个例子：
A Matcher examines the results of applying a pattern.
我们希望从这句话中找到所有开头为a的单词。
当然这只是一个简单的例子，你可以使用String提供的split方法，得到单词数组，然后
遍历各个单词看是否是否开头为a
我们现在看看怎么使用正则表达式来处理这个问题：

Java代码
import java.util.regex.*;   
  
public class FindA{   
  public static void main(String args[])   
  throws Exception{   
  
    String candidate =   
     "A Matcher examines the results of applying a pattern.";   
    String regex = "\\ba\\w*\\b";   
    Pattern p = Pattern.compile(regex);   
    Matcher m = p.matcher(candidate);   
    String val = null;   
    System.out.println("INPUT: " + candidate);   
    System.out.println("REGEX: " + regex +"\r\n");   
    while (m.find()){   
      val = m.group();   
      System.out.println("MATCH: " + val);   
    }   
    if (val == null) {   
      System.out.println("NO MATCHES: ");   
    }   
  }   
} 
import java.util.regex.*;

public class FindA{
  public static void main(String args[])
  throws Exception{

    String candidate =
     "A Matcher examines the results of applying a pattern.";
    String regex = "\\ba\\w*\\b";
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(candidate);
    String val = null;
    System.out.println("INPUT: " + candidate);
    System.out.println("REGEX: " + regex +"\r\n");
    while (m.find()){
      val = m.group();
      System.out.println("MATCH: " + val);
    }
    if (val == null) {
      System.out.println("NO MATCHES: ");
    }
  }
}

从这个例子我们可以看到正则表达式涉及到的两个类Matcher和Pattern,我们以后会专门讨论着连个类。现在主要看看使用正则表达式的流程：
首先使用　Pattern的一个静态的方法compile来创建Pattern对象，

Java代码
Pattern p = Pattern.compile(regex); 
Pattern p = Pattern.compile(regex);

然后调用Pattern的方法matcher

Java代码
Matcher m = p.matcher(candidate); 
 Matcher m = p.matcher(candidate);

得到了Matcher对象，Matcher对象保存了许多匹配信息，然后可以通过find()方法
查找匹配的部分，如果有匹配的部分，返回真，使用m.group方法得到匹配的各组值，
否则find返回false.
当然这只是一般的过程，还有许多更细的方法，在以后会陆续的总结，下面我们看一下

Java代码
String regex = "\\ba\\w*\\b"; 
String regex = "\\ba\\w*\\b";

这个就是一个正则表达式，b,w,*都是正则表达式的meta character原字符，
\b表示单词的边界，w表示任意的可构成单词的字母数字，*表示前面的字母(当然可以
是更复杂的组之类的了东东)重复0次或0次以上，a当然还是a了。所以这个regex就
匹配单词开头为a的单词了。
二、下面总结一下基本的正则表达式的meta character以及它们含义：
. 匹配任意一个字符　$　匹配一行的结尾　^　匹配一行的开头(在[]里面表示否定)
{}　定义了一个范围　 [] 定义了一个字符类　() 定义了一个组
*前面出现0次以上 +　前面匹配一次以上　?前面出现0次或一次　　
\　后面的字符不会看作metacharacter \w 字母数字下划线　\W 非字母数字下划线
\d 单个数字　\D单个非数字　| 或，二者之一　&&与操作符 \b单词边界
下面看看几个简单的例子：
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
三、java.util.regex提供的操作接口：
java.util.regex包提供了操作正则表达式的模型，整个模型优雅而简洁，只有三个类：Pattern、Matcher和
PatternSyntaxException。下面将要总结他们提供的方法，以及如何灵活应用来处理文本。

我们还是从Pattern的静态工厂方法来扩展吧：

Java代码
static Pattern compile(String regex)  
static Pattern compile(String regex)

将给定的正则表达式编译到模式中，并创建Pattern对象，这个方法通常是操作正则表达式的第一步，从前面那个例子
我们也可以看到整个的流程。
在看看一个重载的compile方法：

Java代码
    
static Pattern compile(String regex, int flags)  
 
static Pattern compile(String regex, int flags)

将给定的正则表达式编译到具有给定标志的模式中。 这个方法参数flags提供了一些特殊的选项来用于特殊的处理，
我们下面看看可使用的选项：
UNIX_LINES：这个主要处理UNIX和其他的操作系统在行结束符不一样的问题，UNIX使用\n代表一行的终止，而Windows
则使用了\r\n,\n,\r,\u2028或者\u0085作为一行的结束符。
CASE_INSENSITIVE：当我们在匹配的时候要忽略字符大小写时
COMMENTS:允许我们在正则表达式中使用注释，例如

Java代码
Pattern p =Pattern.compile("A    #matches uppercase US-ASCII char code 65",Pattern.COMMENTS); 
Pattern p =Pattern.compile("A    #matches uppercase US-ASCII char code 65",Pattern.COMMENTS);

MULTILINE:表明要输入多行，他们有自己的终止字符。

Java代码
Pattern p = Pattern.compile("^", Pattern.MULTILINE); 
Pattern p = Pattern.compile("^", Pattern.MULTILINE);

如果你的输入的字符串是：This is a sentence.\n So is this..
这样我们匹配的字符时This中的T和So中的S，如果不使用MULTILINE，则只会匹配T
DOTALL:使用这个选项之后metacharacter .就可以包括一行的终止字符了，如果没有这个选项，
一行的终止字符，并不会考虑在字符串之内的。
使用这个选项会降低效率

Java代码
Pattern p = Pattern.compile(".", Pattern.DOTALL); 
Pattern p = Pattern.compile(".", Pattern.DOTALL);

如果我们输入的是Test\n，则匹配的字符是5个。
UNICODE_CASE:处理UNICODE字符集，使用这个选项会降低效率
CANON_EQ：一个字符的实际存储形式是经过编码后的数字，使用CANON_EQ选项就可以匹配一个字母在各种编码了。
例如a可以匹配+00E0和U+0061U+0300
使用这个选项会降低效率
我们可以组合以上选项，只要使用|,进行按位或操作即可

Java代码
Pattern p =   
Pattern.compile("t # a compound flag example",Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE|   
Pattern.COMMENT); 
Pattern p =
Pattern.compile("t # a compound flag example",Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE|
Pattern.COMMENT);

我们还要注意点的时Java对转译字符\的处理，例如我们要匹配一个数字：
我们不能使用：

Java代码
Pattern p = Pattern.compile("\d"); 
Pattern p = Pattern.compile("\d");

而是：

Java代码
Pattern p = Pattern.compile("\\d"); 
Pattern p = Pattern.compile("\\d");

另外如果regex本身形式是错误的，compile方法会抛出java.util.regex.PatternSyntaxException异常。
下面我们总结一下public Matcher matcher(CharSequence input)方法：
当我们使用compile操作，创建了Pattern对象之后，我们就可以使用Pattern对象的matcher操作，生成
matcher对象了，Matcher对象包含了许多对匹配结果集的操作，我们在总结Matcher对象的时候再说。另外
顺便提一下参数CharSequence，CharBuffer, Segment, String, StringBuffer, StringBuilder 都实现了
这个接口，所以参数可以是这些中的任一种类型了。
下面我们看看：

Java代码
public int flags() 
public int flags()

这个方法返回了我们前面可以设置的并且已经设置的flags选项，我们通过按位与来判断是否设置了某个选项：

Java代码
int flgs = myPattern.flags();   
boolean isUsingCommentFlag =( Pattern.COMMENTS == (Pattern.COMMENTS & flgs)) ; 
int flgs = myPattern.flags();
boolean isUsingCommentFlag =( Pattern.COMMENTS == (Pattern.COMMENTS & flgs)) ;

看看一个简化过程的方法：

Java代码
public static boolean matches (String regex,CharSequence input) 
public static boolean matches (String regex,CharSequence input)

这个方法实际上是：

Java代码
Pattern p = Pattern.compile(regex);   
Matcher m = p.matcher(candidate);   
m.matches() 
 Pattern p = Pattern.compile(regex);
 Matcher m = p.matcher(candidate);
 m.matches()

过程的一个简化,我们在后面总结Matcher中的matches方法之后就会理解这个了。
想必我们经常使用把字符串提取出token变成字符串数组的String中的split方法吧，下面我们看看
类似的一个方法：
public String[] split(CharSequence input)
这个方法提供了强大的功能，因为它可以使用正则表达式来作为token的分割：

Java代码
Pattern p = new Pattern.compile(",|and");   
String fruits[] = p.split("apple,banana and orange"); 
 Pattern p = new Pattern.compile(",|and");
 String fruits[] = p.split("apple,banana and orange");

split的一个重载的版本：

Java代码
public String[] split(CharSequence input, int limit) 
public String[] split(CharSequence input, int limit)

它指定了划分的组数，有以下三种情况：
limit==0
这时候和没有limit参数的那个split效果一样
limit>0
如果你仅仅对前limit个感兴趣，你可以使用limit：

Java代码
String[] tmp = pattern.split("Hello, Dolly, You, Are, My, Favorite",3);   
//tmp[0] is  "Hello",   
// tmp[1] is "Dolly";   
//tmp[2] is  "You, Are, My, Favorite"; 
String[] tmp = pattern.split("Hello, Dolly, You, Are, My, Favorite",3);
//tmp[0] is  "Hello",
// tmp[1] is "Dolly";
//tmp[2] is  "You, Are, My, Favorite";

limit<0
会尽可能的划分所有的组，即使分割符后面是个空字符，也要单独生成一个token:""

Java代码
Pattern p = Pattern.compile(",");   
String temp[] = p.split("Hello,Dolly,", -1);   
//temp[]={"Hello","Dolly",""} 
Java正则表达式(二)
关键字: java regex, regular expression
Matcher类:
使用Matcher类,最重要的一个概念必须清楚:组(Group),在正则表达式中
()定义了一个组,由于一个正则表达式可以包含很多的组,所以下面先说说怎么划分组的,
以及这些组和组的下标怎么对应的.
下面我们看看一个小例子,来说明这个问题

引用
\w(\d\d)(\w+)

这个正则表达式有三个组:
整个\w(\d\d)(\w+) 是第0组 group(0)
(\d\d)是第1组 group(1)
(\w+)是第2组 group(2)
我们看看和正则表达式匹配的一个字符串x99SuperJava，
group(0)永远都是匹配整个表达式的字符串的那部分x99SuperJava
group(1)是第1组(\d\d)匹配的部分:99
group(2)是第二组(\w+)匹配的那部分SuperJava
下面我们写一个程序来验证一下：

Java代码
package edu.jlu.fuliang;   
  
import java.util.regex.Matcher;   
import java.util.regex.Pattern;   
  
  
public class RegexTest {   
    public static void main(String[] args) {   
        String regex = "\\w(\\d\\d)(\\w+)";   
        String candidate = "x99SuperJava";   
           
        Pattern p = Pattern.compile(regex);   
        Matcher matcher = p.matcher(candidate);   
        if(matcher.find()){   
            int gc = matcher.groupCount();   
            for(int i = 0; i <= gc; i++)   
                System.out.println("group " + i + " :" + matcher.group(i));   
        }   
    }   
} 
package edu.jlu.fuliang;

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

public class RegexTest {
    public static void main(String[] args) {
        String regex = "\\w(\\d\\d)(\\w+)";
        String candidate = "x99SuperJava";
       
        Pattern p = Pattern.compile(regex);
        Matcher matcher = p.matcher(candidate);
        if(matcher.find()){
            int gc = matcher.groupCount();
            for(int i = 0; i <= gc; i++)
                System.out.println("group " + i + " :" + matcher.group(i));
        }
    }
}

输出结果:

引用
group 0 :x99SuperJava
group 1 :99
group 2 :SuperJava

下面我们看看Matcher类提供的方法：
public Pattern pattern()
这个方法返回了，创建Matcher的那个pattern对象。
下面我们看看一个小例子来说明这个结果

Java代码
import java.util.regex.*;   
  
public class MatcherPatternExample{   
  public static void main(String args[]){   
      test();   
  }   
  
  public static void test(){   
     Pattern p = Pattern.compile("\\d");   
     Matcher m1 = p.matcher("55");   
     Matcher m2 = p.matcher("fdshfdgdfh");   
  
     System.out.println(m1.pattern() == m2.pattern());   
     //return true   
  }   
} 
import java.util.regex.*;

public class MatcherPatternExample{
  public static void main(String args[]){
      test();
  }

  public static void test(){
     Pattern p = Pattern.compile("\\d");
     Matcher m1 = p.matcher("55");
     Matcher m2 = p.matcher("fdshfdgdfh");

     System.out.println(m1.pattern() == m2.pattern());
     //return true
  }
}

public Matcher reset()
这个方法将Matcher的状态重新设置为最初的状态。
public Matcher reset(CharSequence input)
重新设置Matcher的状态，并且将候选字符序列设置为input后进行Matcher,
这个方法和重新创建一个Matcher一样，只是这样可以重用以前的对象。
public int start()
这个方法返回了，Matcher所匹配的字符串在整个字符串的的开始下标：
下面我们看看一个小例子

Java代码
public class MatcherStartExample{   
  public static void main(String args[]){   
      test();   
  }   
  public static void test(){   
     //create a Matcher and use the Matcher.start() method   
     String candidateString = "My name is Bond. James Bond.";   
     String matchHelper[] =   
      {"          ^","                      ^"};   
     Pattern p = Pattern.compile("Bond");   
     Matcher matcher = p.matcher(candidateString);   
  
     //Find the starting point of the first 'Bond'   
      matcher.find();   
      int startIndex = matcher.start();   
      System.out.println(candidateString);   
      System.out.println(matchHelper[0] + startIndex);   
  
     //Find the starting point of the second 'Bond'   
      matcher.find();   
      int nextIndex = matcher.start();   
      System.out.println(candidateString);   
      System.out.println(matchHelper[1] + nextIndex);   
} 
public class MatcherStartExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Matcher and use the Matcher.start() method
     String candidateString = "My name is Bond. James Bond.";
     String matchHelper[] =
      {"          ^","                      ^"};
     Pattern p = Pattern.compile("Bond");
     Matcher matcher = p.matcher(candidateString);

     //Find the starting point of the first 'Bond'
      matcher.find();
      int startIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[0] + startIndex);

     //Find the starting point of the second 'Bond'
      matcher.find();
      int nextIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[1] + nextIndex);
}

输出结果：
My name is Bond. James Bond.
^11
My name is Bond. James Bond.
^23
public int start(int group)
这个方法可以指定你感兴趣的sub group,然后返回sup group匹配的开始位置。
public int end()
这个和start()对应，返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
其实start和end经常是一起配合使用来返回匹配的子字符串。
public int end(int group)
和public int start(int group)对应，返回在sup group匹配的子字符串最后一个字符在整个字符串下标加一
public String group()
返回由以前匹配操作所匹配的输入子序列。
这个方法提供了强大而方便的工具，他可以等同使用start和end,然后对字符串作substring(start,end)操作。
看看下面一个小例子：

Java代码
import java.util.regex.*;   
  
public class MatcherGroupExample{   
  public static void main(String args[]){   
      test();   
  }   
  public static void test(){   
      //create a Pattern   
      Pattern p = Pattern.compile("Bond");   
  
      //create a Matcher and use the Matcher.group() method   
      String candidateString = "My name is Bond. James Bond.";   
      Matcher matcher = p.matcher(candidateString);   
      //extract the group   
      matcher.find();   
      System.out.println(matcher.group());   
  }   
} 
import java.util.regex.*;

public class MatcherGroupExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
      //create a Pattern
      Pattern p = Pattern.compile("Bond");

      //create a Matcher and use the Matcher.group() method
      String candidateString = "My name is Bond. James Bond.";
      Matcher matcher = p.matcher(candidateString);
      //extract the group
      matcher.find();
      System.out.println(matcher.group());
  }
}

public String group(int group)
这个方法提供了强大而方便的工具，可以得到指定的group所匹配的输入字符串
应为这两个方法经常使用，同样我们看一个小例子：

Java代码
import java.util.regex.*;   
  
public class MatcherGroupParamExample{   
  public static void main(String args[]){   
      test();   
  }   
  public static void test(){   
     //create a Pattern   
      Pattern p = Pattern.compile("B(ond)");   
  
     //create a Matcher and use the Matcher.group(int) method   
     String candidateString = "My name is Bond. James Bond.";   
     //create a helpful index for the sake of output   
     Matcher matcher = p.matcher(candidateString);   
     //Find group number 0 of the first find   
      matcher.find();   
      String group_0 = matcher.group(0);   
      String group_1 = matcher.group(1);   
      System.out.println("Group 0 " + group_0);   
      System.out.println("Group 1 " + group_1);   
      System.out.println(candidateString);   
  
     //Find group number 1 of the second find   
      matcher.find();   
      group_0 = matcher.group(0);   
      group_1 = matcher.group(1);   
      System.out.println("Group 0 " + group_0);   
      System.out.println("Group 1 " + group_1);   
      System.out.println(candidateString);   
  }   
} 
import java.util.regex.*;

public class MatcherGroupParamExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Pattern
      Pattern p = Pattern.compile("B(ond)");

     //create a Matcher and use the Matcher.group(int) method
     String candidateString = "My name is Bond. James Bond.";
     //create a helpful index for the sake of output
     Matcher matcher = p.matcher(candidateString);
     //Find group number 0 of the first find
      matcher.find();
      String group_0 = matcher.group(0);
      String group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);

     //Find group number 1 of the second find
      matcher.find();
      group_0 = matcher.group(0);
      group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);
  }
}

public int groupCount()
这个方法返回了，正则表达式的匹配的组数。
public boolean matches()
尝试将整个区域与模式匹配。这个要求整个输入字符串都要和正则表达式匹配。
和find不同， find是会在整个输入字符串查找匹配的子字符串。
public boolean find()
find会在整个输入中寻找是否有匹配的子字符串，一般我们使用find的流程：

Java代码
while(matcher.find()){   
   //在匹配的区域，使用group,replace等进行查看和替换操作   
} 
 while(matcher.find()){
    //在匹配的区域，使用group,replace等进行查看和替换操作
 }

public boolean find(int start)
从输入字符串指定的start位置开始查找。
public boolean lookingAt()
基本上是matches更松约束的一个方法，尝试将从区域开头开始的输入序列与该模式匹配
public Matcher appendReplacement (StringBuffer sb, String replacement)
你想把My name is Bond. James Bond. I would like a martini中的Bond换成Smith

Java代码
StringBuffer sb = new StringBuffer();   
String replacement = "Smith";   
Pattern pattern = Pattern.compile("Bond");   
Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");   
while(matcher.find()){   
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith   
} 
StringBuffer sb = new StringBuffer();
String replacement = "Smith";
Pattern pattern = Pattern.compile("Bond");
Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");
while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}

Matcher对象会维护追加的位置，所以我们才能不断地使用appendReplacement来替换所有的匹配。
public StringBuffer appendTail(StringBuffer sb)
这个方法简单的把为匹配的结尾追加到StringBuffer中。在上一个例子的最后再加上一句：
matcher.appendTail(sb);
结果就会成为My name is Smith. James Smith. I would like a martini.
public String replaceAll(String replacement)
这个是一个更方便的方法，如果我们想替换所有的匹配的话，我们可以简单的使用replaceAll就ok了。
是：

Java代码
while(matcher.find()){   
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith   
}   
matcher.appendTail(sb); 
while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}
matcher.appendTail(sb);

的更便捷的方法。

Java代码
public String replaceFirst(String replacement) 
public String replaceFirst(String replacement)
这个与replaceAll想对应很容易理解，就是只替换第一个匹配的。
 
[size=12px]1。^\d+$　　//匹配非负整数（正整数 + 0）
2。^[0-9]*[1-9][0-9]*$　　//匹配正整数
3。^((-\d+)|(0+))$　　//匹配非正整数（负整数 + 0）
4。^-[0-9]*[1-9][0-9]*$　　//匹配负整数
5。^-?\d+$　　　　//匹配整数
6。^\d+(\.\d+)?$　　//匹配非负浮点数（正浮点数 + 0）
7。^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$　　//匹配正浮点数
8。^((-\d+(\.\d+)?)|(0+(\.0+)?))$　　//匹配非正浮点数（负浮点数 + 0）
9。^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$　　//匹配负浮点数
10。^(-?\d+)(\.\d+)?$　　//匹配浮点数
11。^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
12。^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
13。^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
14。^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
15。^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
16。^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$　　　　//匹配email地址
17。^[a-zA-z]+://匹配(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$　　//匹配url
18。匹配中文字符的正则表达式： [\u4e00-\u9fa5]
19。匹配双字节字符(包括汉字在内)：[^\x00-\xff]
20。应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}
21。匹配空行的正则表达式：\n[\s| ]*\r
22。匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
23。匹配首尾空格的正则表达式：(^\s*)|(\s*$)

* 正则表达式用例
  * 1、^\S+[a-z A-Z]$ 不能为空 不能有空格  只能是英文字母
  * 2、\S{6,}         不能为空 六位以上
  * 3、^\d+$          不能有空格 不能非数字
  * 4、(.*)(\.jpg|\.bmp)$ 只能是jpg和bmp格式
  * 5、^\d{4}\-\d{1,2}-\d{1,2}$ 只能是2004-10-22格式
  * 6、^0$            至少选一项
  * 7、^0{2,}$        至少选两项
  * 8、^[\s|\S]{20,}$ 不能为空 二十字以上
  * 9、^\+?[a-z0-9](([-+.]|[_]+)?[a-z0-9]+)*@([a-z0-9]+(\.|\-))+[a-z]{2,6}$邮件
  * 10、\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*([,;]\s*\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)* 输入多个地址用逗号或空格分隔邮件
  * 11、^(\([0-9]+\))?[0-9]{7,8}$电话号码7位或8位或前面有区号例如（022）87341628
  * 12、^[a-z A-Z 0-9 _]+@[a-z A-Z 0-9 _]+(\.[a-z A-Z 0-9 _]+)+(\,[a-z A-Z 0-9 _]+@[a-z A-Z 0-9 _]+(\.[a-z A-Z 0-9 _]+)+)*$
  *     只能是字母、数字、下划线；必须有@和.同时格式要规范 邮件
  * 13 ^\w+@\w+(\.\w+)+(\,\w+@\w+(\.\w+)+)*$上面表达式也可以写成这样子，更精练。
    14   ^\w+((-\w+)|(\.\w+))*\@\w+((\.|-)\w+)*\.\w+$ [/size]
 
21。匹配空行的正则表达式：\n[\s ¦ ]*\r
21。匹配空行的正则表达式：/^\s*$/m

22。匹配HTML标记的正则表达式：/ <(.*)>.* <\/\1> ¦ <(.*)\/>/
22。匹配HTML标记的正则表达式：/ <([^>]+)>[^ <>]* <\/\1> ¦ <([^>]+)\/>/
这个实际上作用不大，因为正则表达式不能支持嵌套匹配，仅 .NET 的表达式引擎有这个功能。

23。匹配首尾空格的正则表达式：(^\s*) ¦(\s*$)
23。匹配首尾空格的正则表达式：^\s+ ¦\s+$
    为 JavaScript 的 String 增加 trim() 函数：
    String.prototype.trim = function() {
      return this.replace(/^\s+/, '').replace(/\s+$/, '');
  }

* 4、(.*)(\.jpg ¦\.bmp)$ 只能是jpg和bmp格式

* 8、^[\s ¦\S]{20,}$ 不能为空 二十字以上
匹配中文字符的正则表达式： [\u4e00-\u9fa5] 
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了 
 
匹配双字节字符(包括汉字在内)：[^\x00-\xff] 
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） 
 
匹配空白行的正则表达式：\n\s*\r 
评注：可以用来删除空白行 
 
匹配HTML标记的正则表达式： <(\S*?)[^>]*>.*? ¦ <.*? /> 
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力 
 
匹配首尾空白字符的正则表达式：^\s* ¦\s*$ 
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式 
 
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* 
评注：表单验证时很实用 
 
匹配网址URL的正则表达式：[a-zA-z]+://[^\s]* 
评注：网上流传的版本功能很有限，上面这个基本可以满足需求 
 
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
评注：表单验证时很实用 
 
匹配国内电话号码：\d{3}-\d{8} ¦\d{4}-\d{7} 
评注：匹配形式如 0511-4405222 或 021-87888822 
 
匹配腾讯QQ号：[1-9][0-9]{4,} 
评注：腾讯QQ号从10000开始 
 
匹配中国邮政编码：[1-9]\d{5}(?!\d) 
评注：中国邮政编码为6位数字 
 
匹配身份证：\d{15} ¦\d{18} 
评注：中国的身份证为15位或18位 
 
匹配ip地址：\d+\.\d+\.\d+\.\d+ 
评注：提取ip地址时有用 
 
匹配特定数字： 
^[1-9]\d*$　 　 //匹配正整数 
^-[1-9]\d*$ 　 //匹配负整数 
^-?[1-9]\d*$　　 //匹配整数 
^[1-9]\d* ¦0$　 //匹配非负整数（正整数 + 0） 
^-[1-9]\d* ¦0$　　 //匹配非正整数（负整数 + 0） 
^[1-9]\d*\.\d* ¦0\.\d*[1-9]\d*$　　 //匹配正浮点数 
^-([1-9]\d*\.\d* ¦0\.\d*[1-9]\d*)$　 //匹配负浮点数 
^-?([1-9]\d*\.\d* ¦0\.\d*[1-9]\d* ¦0?\.0+ ¦0)$　 //匹配浮点数 
^[1-9]\d*\.\d* ¦0\.\d*[1-9]\d* ¦0?\.0+ ¦0$　　 //匹配非负浮点数（正浮点数 + 0） 
^(-([1-9]\d*\.\d* ¦0\.\d*[1-9]\d*)) ¦0?\.0+ ¦0$　　//匹配非正浮点数（负浮点数 + 0） 
评注：处理大量数据时有用，具体应用时注意修正 
 
匹配特定字符串： 
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串 
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串 
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串 
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串 
^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串 
"^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+___FCKpd___0quot;　　　　//email地址   
"^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?___FCKpd___0quot;　　//url 

匹配中文字符的正则表达式： [\u4e00-\u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^\x00-\xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：\n\s*\r
评注：可以用来删除空白行

匹配HTML标记的正则表达式： <(\S*?)[^>]*>.*? ¦ <.*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^\s* ¦\s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用

匹配国内电话号码：\d{3}-\d{8} ¦\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]\d{5}(?!\d)
评注：中国邮政编码为6位数字

匹配身份证：\d{15} ¦\d{18}
评注：中国的身份证为15位或18位

匹配ip地址：\d+\.\d+\.\d+\.\d+
评注：提取ip地址时有用

匹配特定数字：
^[1-9]\d*$　 　 //匹配正整数
^-[1-9]\d*$ 　 //匹配负整数
^-?[1-9]\d*$　　 //匹配整数
^[1-9]\d* ¦0$　 //匹配非负整数（正整数 + 0）
^-[1-9]\d* ¦0$　　 //匹配非正整数（负整数 + 0）
^[1-9]\d*\.\d* ¦0\.\d*[1-9]\d*$　　 //匹配正浮点数
^-([1-9]\d*\.\d* ¦0\.\d*[1-9]\d*)$　 //匹配负浮点数
^-?([1-9]\d*\.\d* ¦0\.\d*[1-9]\d* ¦0?\.0+ ¦0)$　 //匹配浮点数
^[1-9]\d*\.\d* ¦0\.\d*[1-9]\d* ¦0?\.0+ ¦0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]\d*\.\d* ¦0\.\d*[1-9]\d*)) ¦0?\.0+ ¦0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
"^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+___FCKpd___0quot;　　　　//email地址
"^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?___FCKpd___0quot;　　//urlview plaincopy to clipboardprint?
正则几个基本概念： 

正则几个基本概念：view plaincopy to clipboardprint?
1.贪婪：+,*,?,{m,n}等默认是贪婪匹配，即尽可能多匹配，也叫最大匹配 
如果后面加上?，就转化为非贪婪匹配，需要高版本支持 

1.贪婪：+,*,?,{m,n}等默认是贪婪匹配，即尽可能多匹配，也叫最大匹配
如果后面加上?，就转化为非贪婪匹配，需要高版本支持view plaincopy to clipboardprint?
2.获取：默认用(x ¦y)是获取匹配，很多时候只是测试，不一定要求得到所匹配的数据，尤其在嵌套匹配或大数据中就要用非获取匹配(?:x ¦y)，这样提高了效率，优化了程序。 

2.获取：默认用(x ¦y)是获取匹配，很多时候只是测试，不一定要求得到所匹配的数据，尤其在嵌套匹配或大数据中就要用非获取匹配(?:x ¦y)，这样提高了效率，优化了程序。view plaincopy to clipboardprint?
3.消耗：默认是消耗匹配，一般在预查中是非消耗匹配。 
举个例子，2003-2-8要变为2003-02-08 
如果用/-(\d)-/第二次匹配将从8开始，从而只替换第一个2，错误 
如果用/-(\d)(?=-)/则第二次匹配从第二个-开始，即不消耗字符- 

3.消耗：默认是消耗匹配，一般在预查中是非消耗匹配。
举个例子，2003-2-8要变为2003-02-08
如果用/-(\d)-/第二次匹配将从8开始，从而只替换第一个2，错误
如果用/-(\d)(?=-)/则第二次匹配从第二个-开始，即不消耗字符-view plaincopy to clipboardprint?
4.预查：js中分为正向预查和负向预查 
如上面的(?=pattern)是正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。还有(?!pattern)是负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。负向预查有时会用在对[^]的扩充，[^]只是一些字符，而?!可以使整个字符串。 

4.预查：js中分为正向预查和负向预查
如上面的(?=pattern)是正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。还有(?!pattern)是负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。负向预查有时会用在对[^]的扩充，[^]只是一些字符，而?!可以使整个字符串。view plaincopy to clipboardprint?
5.回调：一般用在替换上，即根据不用的匹配内容返回不用的替换值，从而简化了程序，需要高版本支持 

5.回调：一般用在替换上，即根据不用的匹配内容返回不用的替换值，从而简化了程序，需要高版本支持view plaincopy to clipboardprint?
6.引用：\num 对所获取的第num个匹配的引用。 
例如，'(.)\1\1' 匹配AAA型。'(.)(.)\2\1' 匹配ABBA型。 

6.引用：\num 对所获取的第num个匹配的引用。
例如，'(.)\1\1' 匹配AAA型。'(.)(.)\2\1' 匹配ABBA型。view plaincopy to clipboardprint?
正则表达式保留字 
^ (carat)   
. (period)   
[ (left bracket}   
$ (dollar sign)   
( (left parenthesis)   
) (right parenthesis)   
¦ (pipe)   
* (asterisk)   
+ (plus symbol)   
? (question mark)   
{ (left curly bracket, or left brace)   
\ backslash 

正则表达式保留字
^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
¦ (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
\ backslash view plaincopy to clipboardprint?
构造 匹配于 

构造 匹配于 view plaincopy to clipboardprint?
字符   
x 字符 x   
\\ 反斜线字符   
\0n 八进制值的字符0n (0 <= n <= 7)   
\0nn 八进制值的字符 0nn (0 <= n <= 7)   
\0mnn 八进制值的字符0mnn 0mnn (0 <= m <= 3, 0 <= n <= 7)   
\xhh 十六进制值的字符0xhh   
\uhhhh 十六进制值的字符0xhhhh   
\t 制表符('\u0009')   
\n 换行符 ('\u000A')   
\r 回车符 ('\u000D')   
\f 换页符 ('\u000C')   
\a 响铃符 ('\u0007')   
\e 转义符 ('\u001B')   
\cx T对应于x的控制字符 x 

字符
x 字符 x
\\ 反斜线字符
\0n 八进制值的字符0n (0 <= n <= 7)
\0nn 八进制值的字符 0nn (0 <= n <= 7)
\0mnn 八进制值的字符0mnn 0mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh 十六进制值的字符0xhh
\uhhhh 十六进制值的字符0xhhhh
\t 制表符('\u0009')
\n 换行符 ('\u000A')
\r 回车符 ('\u000D')
\f 换页符 ('\u000C')
\a 响铃符 ('\u0007')
\e 转义符 ('\u001B')
\cx T对应于x的控制字符 x view plaincopy to clipboardprint?
字符类   
[abc] a, b, or c (简单类)   
[^abc] 除了a、b或c之外的任意 字符（求反）   
[a-zA-Z] a到z或A到Z ，包含（范围)   
[a-z-[bc]] a到z，除了b和c ： [ad-z]（减去）   
[a-z-[m-p]] a到z，除了m到 p： [a-lq-z]   
[a-z-[^def]] d, e, 或 f 

字符类
[abc] a, b, or c (简单类)
[^abc] 除了a、b或c之外的任意 字符（求反）
[a-zA-Z] a到z或A到Z ，包含（范围)
[a-z-[bc]] a到z，除了b和c ： [ad-z]（减去）
[a-z-[m-p]] a到z，除了m到 p： [a-lq-z]
[a-z-[^def]] d, e, 或 f view plaincopy to clipboardprint?
预定义的字符类   
. 任意字符（也许能与行终止符匹配，也许不能）   
\d 数字: [0-9]   
\D 非数字: [^0-9]   
\s 空格符: [ \t\n\x0B\f\r]   
\S 非空格符: [^\s]   
\w 单词字符: [a-zA-Z_0-9]   
\W 非单词字符: [^\w] 

 

 

 

这几天看了下正则表达式，对非捕获组(non-capturing)进行下总结。
主要总结 1个 + 2组  一共5个。
(?:X) (?=X) (?<=X) (?!X) (?<!X)

一、先从(?:)非捕获组说起。
下面由一个例子引出非捕获组。

有两个金额：8899￥ 和 6688$ 。显然，前一个是8899元的人民币，后一个是6688元的美元。我现在需要一个正则，要求提炼出它们的货币金额和货币种类。正则可以这写：(\\d)+([￥$])$  (在java中测试，所以多了转义字符'\')
测试程序如下：

   

Pattern p = Pattern.compile("(\\d+)([￥$])$"); 
     String str = "8899￥"; 
     Matcher m = p.matcher(str); 
     if(m.matches()){ 
      System.out.println("货币金额: " + m.group(1)); 
      System.out.println("货币种类: " + m.group(2)); 
    } 

 

输出结果为：
货币金额: 8899
货币种类: ￥

OK,满足了要求。这里的正则分成了两个组，一个是(\\d+)，一个是([￥$])，前一个组匹配货币金额，后一个组匹配货币种类。

现在，我需要这个正则可以匹配浮点数。如8899.56￥。我们都知道，现在少于一元钱基本上买不到东西了，所以我希望忽略小数部分，正则还是提炼出 8899 和 ￥。
那么正则如下：
[code="java"](\\d+)(\\.?)(\\d+)([￥$])$[/code]
这里用括号分了四组，所以要输出货币金额的整数部分和货币种类，要分别输了group(1),group(4)了。如果输出部分和正则是分开的，我希望只修改正则而不去修改输出部分的代码，也就是还是用group(1)，group(2)作为输出。由此可以引出非捕获组(?:)。
把前面的正则修改为：
[code="java"](\\d+)(?:\\.?)(?:\\d+)([￥$])$[/code]
这样，还是用group(1),group(2)做为输出，同样输出了 8899 和 ￥
这个正则的中间两个组用到的就是非捕获组（?:），它可以理解为只分组而不捕获。

二、(?=)和(?<=)
有的资料把它们叫做肯定式向前查找和肯定式向后查找；
有的资料也叫做肯定顺序环视和肯定逆序环视。

1、姑且不理它们的名称，看下面的例子：

  

Pattern p = Pattern.compile("[0-9a-z]{2}(?=aa)"); 
   String str = "12332aa438aaf"; 
  
    Matcher m = p.matcher(str); 
    while(m.find()){ 
     System.out.println(m.group()); 
   } 

 

这段程序输出32 38
这个正则的意思是：匹配这么一个字符串，它要满足：是两位字符（数字，或字母），且[color=red]后面[/color]紧跟着两个a。
分析一下：
32aa  这个子串 满足这个条件，所以可以匹配到，又因为 (?=) 的部分是不捕获的，所以输出的只是 32，不包括aa。同理 38aa 也匹配这个正则，而输出仅是 38。

再深入看一下:
当str第一次匹配成功输出 32 后，程序要继续向后查找是否还有匹配的其它子串。那么这时应该从 32aa 的后一位开始向后查找，还是从 32 的后一位呢？也就是从索引 5 开始还是从 7 开始呢？有人可能想到是从 32aa 的下一位开始往后找，因为 32aa 匹配了正则，所以下一位当然是它的后面也就是从 4 开始。但实际上是从 32 的后一位也就是第一个 a 开始往后找。原因还是 (?=) 是非捕获的。
查阅API文档是这么注释的：

(?=X) X, via zero-width positive lookahead

可见zero-width（零宽度）说的就是这个意思。

现在，把字符串写的更有意思些：str = "aaaaaaaa";
看一下它的输出： aa aa aa
分析一下：
这个字符串一共有8个a。
第一次匹配比较容易找到，那就是前四个：aaaa ,当然第三和第四个 a 是不捕获的，所以输出是第一和第二个a；
接着继续查找，这时是从第三个a开始，三到六，这4个a区配到了，所以输出第三和第四个a；
接着继续查找，这时是从第五个a开始，五到八，这4个a区配到了，所以输出第五和第六个a；
接着往后查找，这时是从第七个a开始，显然，第七和第八个a,不满足正则的匹配条件，查找结束。
我们再延伸一下，刚说的情况的是(?=)放在捕获的字符串后面，它如果放在前面又是什么结果呢？
例子换成：

  

Pattern p = Pattern.compile("(?=hopeful)hope"); 
    String str = "hopeful"; 
    Matcher m = p.matcher(str); 
    while(m.find()){ 
      System.out.println(m.group()); 
    } 

 

它的输出是hope。
正则的意思是：是否能匹配hopeful,如果能，则捕获hopeful中的hope。当然继续向后查找匹配的子串，是从f开始。
比较一下可以看出，(?=hopeful)hope 和 hope(?=ful),两个正则的效果其实是一样的。

2、下面说一下 (?<=)
把正则改一下，
    Pattern p = Pattern.compile("(?<=aa)[0-9a-z]{2}");
字符串还是str = "12332aa438aaf";
它的输出：43。

这个正则的意思是：匹配这么一个字符串，它要满足：是两位字符（数字或字母），且[color=red]前面[/color]紧跟的是两个字母 a 。

同样，深入一下，把str换成str = "aaaaaaaa";看一下输出是什么，同样也是：aa aa aa
分析一下：
第一次匹配不用说，是前四个a，输出的是第三和第四个a;
继续向后查找，从第五个a开始，程序发现，第五个和第六个a满足，因为是两位字符，且满足前面紧跟着两个a(第三和第四个a)。所以匹配成功，输出第五个和第六个a;
继续向后查找，从第七个a开始，程序发现，第七个和第八个a满足，因为是两位字符，且满足前面紧跟着两个a(第五和第六个a)。所以匹配成功，输出第七和第八个a。查找结束。

三、(?!)和(?<!)
从外观上看，和前面一组很相似，区别就是把 ‘=’ 换成了 ‘!’
那么意义刚好也是相反的。
[0-9a-z]{2}(?!aa)    意思是：匹配两个字符，且后面紧跟着的不是aa
(?<=aa)[0-9a-z]{2}  意思是：匹配两个字符，且前面紧跟着的不是aa
用法和前面讲的差不多，这里不再详述。

 

 

 在 java api 文档中的正则表达式关于特殊构造(非捕获组)的说明看不懂。例如：

(?:X)         X，作为非捕获组
(?idmsux-idmsux) Nothing，但是将匹配标志由 on 转为 off
(?idmsux-idmsux:X) X，作为带有给定标志 on - off 的非捕获组
(?=X) X，通过零宽度的正 lookahead
(?!X)  X，通过零宽度的负 lookahead
(?<=X) X，通过零宽度的正 lookbehind
(?<!X) X，通过零宽度的负 lookbehind
(?>X) X，作为独立的非捕获组
 

    这些字都说的很抽象。不懂……。还是搜索下去。找到 火龙果 的解释如下：以 (? 开头，) 结尾的都称为非捕获组，在匹配完成后在内存中不保留匹配到的字符。非捕获组的应用比较复杂，这里只能简单地说一下它们的意思。

1、(?:X) X，作为非捕获组

与捕获组 ( ) 的意思一样也是将其作为一组进行处理，与捕获组的区别在于不捕获匹配的文本，仅仅作为分组。

比如：要匹配 123123 这个，就可以写为 (123)\1 使用反向引用，这时只能用捕获组，在匹配 123 后会保留在内存中，便于反向引用，而 (?:123) 在匹配完后则不会保留，区别仅在于此。

2、(?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on - off

用于标志匹配，比如：表达式 (?i)abc(?-i)def 这时，(?i) 打开不区分大小写开关，abc 匹配不区分大小地进行匹配，(?-i) 关闭标志，恢复不区分大小写，这时的 def 只能匹配 def

3、(?idmsux-idmsux:X)  X，作为带有给定标志 i d m s u x on - off

与上面的类似，上面的表达式，可以改写成为：(?i:abc)def，或者 (?i)abc(?-i:def)

4、(?=X) X，通过零宽度的正 lookahead

5、(?!X) X，通过零宽度的负 lookahead

(?=X) 表示当前位置（即字符的缝隙）后面允许出现的字符，比如：表示式 a(?=b)，在字符串为 ab 时，可能匹配 a，后面的 (?=b) 表示，a 后面的缝隙，可以看作是零宽度。 (?!X) 表示当前位置后面不允许出现的字符

 6、(? <=X) X，通过零宽度的正 lookbehind

7、(? <!X) X，通过零宽度的负 lookbehind

这两个与上面两个类似，上面两个是向后看，这个是向前看

 8、(?>X) X，作为独立的非捕获组

匹配成功不进行回溯，这个比较复杂，也侵占量词“+”可以通用，比如：\d++ 可以写为 (?>\d+)。

 我认为，第1、2、3点比较好理解，4、5、6、7看类懂，还是用示例来说明：从“aacabab”找a，且后面只允许出现b。代码如下：

 Pattern p = Pattern.compile("a(?=b)");
Matcher m = p.matcher("aacabab");
while(m.find()) {
System.out.println(m.group()+", start="+m.start()+", end="+m.end());
}
运行结果：
 a, start=3, end=4
a, start=5, end=6
个人理解：在(?=b)这个“式”后面允许出现b，且这个“式”不占正则表达式位置(所谓0宽度)，lookahead 的意思是b字符的前面，它前面紧接着是a，也就是a后面出现b。

8比较难理解，这个根据 火龙果 推荐的链接找到答案 http://www.regular-expressions.info/atomic.html

其中说的示例：来看 /\b(integer|insert|in)\b/ 匹配 integers 过程，第一个，当integer\b匹配到s时失败，然后字符串(integers)会回溯到i，再接着第二个(insert)去匹配。而把模式写成 /\b(?>integer|insert|in)\b/ 在刚才的第一个匹配失败，字符串(integers)不会回溯了，也不会有第二个去匹配了，所有速度会快一点点。

但是写 (?>X) 这种式子时要注意，是从左到右看的。/\b(?>integer|insert|in)\b/ ，与 /\b(?>in|integer|insert)\b/ 去匹配 insert，结果会不一样，前者可以匹配到，后者不能，什么原因自己分析下。一但匹配失败就会跳过，所以应该长的写在表达式前面.

 

 

 

 

Java代码  1.import java.util.regex.Matcher; 
2.import java.util.regex.Pattern; 
3. 
4.public class PatternTest { 
5. 
6.    public static void main(String[] args) { 
7.        String text = "<textarea rows=\"20\" cols=\"70\">nexus maven repository index properties updating index central</textarea>"; 
8.        String reg = "<textarea.*?>.*?</textarea>"; 
9.        Pattern p = Pattern.compile(reg); 
10.        Matcher m = p.matcher(text); 
11.        while (m.find()) { 
12.            System.out.println(m.group()); 
13.        } 
14.    } 
15. 
16.} 
 

  运行结果：

 

Java代码  1.<textarea rows="20" cols="70">nexus maven repository index properties updating index central</textarea> 
 

 

 现在，如果我只想匹配到<textarea>内的文本内容即“nexus maven repository index properties updating index central”，怎么做呢？这时候就要用到捕获组了。上述代码中“<textarea.*?>.*?</textarea>”最中间的“.*?”是匹配内容的正则表达式，只需要将它用括号括起来，就是一个捕获组了。看代码：

 

Java代码  1.import java.util.regex.Matcher; 
2.import java.util.regex.Pattern; 
3. 
4.public class PatternTest { 
5. 
6.    public static void main(String[] args) { 
7.        String text = "<textarea rows=\"20\" cols=\"70\">nexus maven repository index properties updating index central</textarea>"; 
8.        //下面的正则表达式中共有四个捕获组：(<textarea.*?>)、(.*?)、(</textarea>)和整个匹配到的内容 
9.        String reg = "(<textarea.*?>)(.*?)(</textarea>)";   
10.        Pattern p = Pattern.compile(reg); 
11.        Matcher m = p.matcher(text); 
12.        while (m.find()) { 
13.            System.out.println(m.group(0)); // 整个匹配到的内容 
14.            System.out.println(m.group(1)); // (<textarea.*?>) 
15.            System.out.println(m.group(2)); // (.*?) 
16.            System.out.println(m.group(3)); // (</textarea>) 
17.        } 
18.    } 
19.} 
 

  运行结果：

 

Java代码  1.<textarea rows="20" cols="70">nexus maven repository index properties updating index central</textarea> 
2.<textarea rows="20" cols="70"> 
3.nexus maven repository index properties updating index central 
4.</textarea> 
 

  从上述代码得出结论：正则表达式中每个"()"内的部分算作一个捕获组，每个捕获组都有一个编号，从1,2...，编号0代表整个匹配到的内容。

 至于非捕获组，只需要将捕获组中"()"变为"(?:)"即可，代码说话：

Java代码  1.import java.util.regex.Matcher; 
2.import java.util.regex.Pattern; 
3. 
4.public class PatternTest { 
5. 
6.    public static void main(String[] args) { 
7.        String text = "<textarea rows=\"20\" cols=\"70\">nexus maven repository index properties updating index central</textarea>"; 
8.        // 下面的正则表达式中共有二个捕获组：(.*?)和整个匹配到的内容，两个非捕获组:(?:</textarea>)和(?:<textarea.*?>) 
9.        String reg = "(?:<textarea.*?>)(.*?)(?:</textarea>)"; 
10.        Pattern p = Pattern.compile(reg); 
11.        Matcher m = p.matcher(text); 
12.        while (m.find()) { 
13.            System.out.println(m.group(0)); // 整个匹配到的内容 
14.            System.out.println(m.group(1)); // (.*?) 
15.        } 
16.    } 
17.} 
  运行结果：

Java代码  1.<textarea rows="20" cols="70">nexus maven repository index properties updating index central</textarea> 
2.nexus maven repository index properties updating index central 
  如果试图运行：System.out.println(m.group(2));将会抛出异常，因为不存在编号为2的捕获组。

 

 

 

 

 

附 ： 常用的正则表达式：

匹配特定数字：
^[1-9]d*$　 　 //匹配正整数
^-[1-9]d*$ 　 //匹配负整数
^-?[1-9]d*$　　 //匹配整数
^[1-9]d*|0$　 //匹配非负整数（正整数 + 0）
^-[1-9]d*|0$　　 //匹配非正整数（负整数 + 0）
^[1-9]d*.d*|0.d*[1-9]d*$　　 //匹配正浮点数
^-([1-9]d*.d*|0.d*[1-9]d*)$　 //匹配负浮点数
^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$　 //匹配浮点数
^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串

在使用RegularExpressionValidator验证控件时的验证功能及其验证表达式介绍如下:

只能输入数字：“^[0-9]*$”
只能输入n位的数字：“^d{n}$”
只能输入至少n位数字：“^d{n,}$”
只能输入m-n位的数字：“^d{m,n}$”
只能输入零和非零开头的数字：“^(0|[1-9][0-9]*)$”
只能输入有两位小数的正实数：“^[0-9]+(.[0-9]{2})?$”
只能输入有1-3位小数的正实数：“^[0-9]+(.[0-9]{1,3})?$”
只能输入非零的正整数：“^+?[1-9][0-9]*$”
只能输入非零的负整数：“^-[1-9][0-9]*$”
只能输入长度为3的字符：“^.{3}$”
只能输入由26个英文字母组成的字符串：“^[A-Za-z]+$”
只能输入由26个大写英文字母组成的字符串：“^[A-Z]+$”
只能输入由26个小写英文字母组成的字符串：“^[a-z]+$”
只能输入由数字和26个英文字母组成的字符串：“^[A-Za-z0-9]+$”
只能输入由数字、26个英文字母或者下划线组成的字符串：“^w+$”
验证用户密码:“^[a-zA-Z]w{5,17}$”正确格式为：以字母开头，长度在6-18之间，

只能包含字符、数字和下划线。
验证是否含有^%&’,;=?$”等字符：“[^%&’,;=?$x22]+”
只能输入汉字：“^[u4e00-u9fa5],{0,}$”
验证Email地址：“^w+[-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$”
验证InternetURL：“^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$”
验证电话号码：“^((d{3,4})|d{3,4}-)?d{7,8}$”

正确格式为：“XXXX-XXXXXXX”，“XXXX-XXXXXXXX”，“XXX-XXXXXXX”，

“XXX-XXXXXXXX”，“XXXXXXX”，“XXXXXXXX”。
验证身份证号（15位或18位数字）：“^d{15}|d{}18$”
验证一年的12个月：“^(0?[1-9]|1[0-2])$”正确格式为：“01”-“09”和“1”“12”
验证一个月的31天：“^((0?[1-9])|((1|2)[0-9])|30|31)$”

正确格式为：“01”“09”和“1”“31”。

匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
匹配空行的正则表达式：n[s| ]*r
匹配HTML标记的正则表达式：/< (.*)>.*|< (.*) />/
匹配首尾空格的正则表达式：(^s*)|(s*$)
匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?