java.util.regex
类 Pattern

java.lang.Objectjava.util.regex.Pattern

所有已实现的接口：

Serializable

public final class Pattern
extends Object
implements Serializable

正则表达式的编译表示形式。

指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

因此，典型的调用顺序是

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

在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句

 boolean b = Pattern.matches("a*b", "aaaaab");

此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。

正则表达式的构造摘要

根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 "\b" 与单个退格字符匹配，而 "\\b" 与单词边界匹配。字符串字面值 "\(hello\)" 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 "\\(hello\\)"。

字符类

字符类可以出现在其他字符类中，并且可以包含并集运算符（隐式）和交集运算符 (&&)。并集运算符表示至少包含其某个操作数类中所有字符的类。交集运算符表示包含同时位于其两个操作数类中所有字符的类。

字符类运算符的优先级如下所示，按从最高到最低的顺序排列：

1	字面值转义	\x
2	分组	[...]
3	范围	a-z
4	并集	[a-e][i-u]
5	交集	[a-z&&[aeiou]]

注意，元字符的不同集合实际上位于字符类的内部，而非字符类的外部。例如，正则表达式 . 在字符类内部就失去了其特殊意义，而表达式 - 变成了形成元字符的范围。

行结束符

行结束符 是一个或两个字符的序列，标记输入字符序列的行结尾。以下代码被识别为行结束符：

• 新行（换行）符 ('\n')、
• 后面紧跟新行符的回车符 ("\r\n")、
• 单独的回车符 ('\r')、
• 下一行字符 ('\u0085')、
• 行分隔符 ('\u2028') 或
• 段落分隔符 ('\u2029)。

如果激活 UNIX_LINES 模式，则新行符是惟一识别的行结束符。

如果未指定 DOTALL 标志，则正则表达式 . 可以与任何字符（行结束符除外）匹配。

默认情况下，正则表达式 ^ 和 $ 忽略行结束符，仅分别与整个输入序列的开头和结尾匹配。如果激活 MULTILINE 模式，则 ^ 在输入的开头和行结束符之后（输入的结尾）才发生匹配。处于 MULTILINE 模式中时，$ 仅在行结束符之前或输入序列的结尾处匹配。

组和捕获

捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

1	((A)(B(C)))
2	\A
3	(B(C))
4	(C)

组零始终代表整个表达式。

之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器检索。

与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串 "aba" 与表达式 (a(b)?)+ 相匹配，会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。

以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。

Unicode 支持

此类符合 Unicode Technical Standard #18:Unicode Regular Expression Guidelines 第 1 级和 RL2.1 Canonical Equivalents。

Java 源代码中的 Unicode 转义序列（如 \u2014）是按照 Java Language Specification 的 第 3.3 节中的描述处理的。这样的转义序列还可以由正则表达式分析器直接实现，以便在从文件或键盘击键读取的表达式中使用 Unicode 转义。因此，可以将不相等的字符串 "\u2014" 和 "\\u2014" 编译为相同的模式，从而与带有十六进制值 0x2014 的字符匹配。

与 Perl 中一样，Unicode 块和类别是使用 \p 和 \P 构造编写的。如果输入具有属性 prop，则与 \p{prop} 匹配，而输入具有该属性时与 \P{prop} 不匹配。块使用前缀 In 指定，与在 InMongolian 中一样。可以使用可选前缀 Is 指定类别：\p{L} 和 \p{IsL} 都表示 Unicode 字母的类别。块和类别在字符类的内部和外部都可以使用。

受支持的类别是由 Character 类指定版本中的 The Unicode Standard 的类别。类别名称是在 Standard 中定义的，即标准又丰富。Pattern 所支持的块名称是 UnicodeBlock.forName 所接受和定义的有效块名称。

行为类似 java.lang.Character boolean 是 methodname 方法（废弃的类别除外）的类别，可以通过相同的 \p{prop} 语法来提供，其中指定的属性具有名称 javamethodname。

与 Perl 5 相比较

Pattern 引擎用有序替换项执行传统上基于 NFA 的匹配，与 Perl 5 中进行的相同。

此类不支持 Perl 构造：

• 条件构造 (?{X}) 和 (?(condition)X|Y)、

• 嵌入式代码构造 (?{code}) 和 (??{code})、

• 嵌入式注释语法 (?#comment) 和

• 预处理操作 \l\u、\L 和 \U。

此类支持但 Perl 不支持的构造：

• Possessive 数量词，它可以尽可能多地进行匹配，即使这样做导致所有匹配都成功时也如此。

• 字符类并集和交集，如上文所述。

与 Perl 的显著不同点是：

• 在 Perl 中，\1 到 \9 始终被解释为 Back 引用；如果至少存在多个子表达式，则大于 9 的反斜线转义数按 Back 引用对待，否则在可能的情况下，它将被解释为八进制转义。在此类中，八进制转义必须始终以零开头。在此类中，\1 到 \9 始终被解释为 Back 引用，较大的数被接受为 Back 引用，如果在正则表达式中至少存在多个子表达式的话；否则，分析器将删除数字，直到该数小于或等于组的现有数或者其为一个数字。

• Perl 使用 g 标志请求恢复最后匹配丢失的匹配。此功能是由 Matcher 类显式提供的：重复执行 find 方法调用可以恢复丢失的最后匹配，除非匹配器被重置。

• 在 Perl 中，位于表达式顶级的嵌入式标记对整个表达式都有影响。在此类中，嵌入式标志始终在它们出现的时候才起作用，不管它们位于顶级还是组中；在后一种情况下，与在 Perl 中类似，标志在组的结尾处还原。

• Perl 允许错误匹配构造，如在表达式 *a 中，以及不匹配的括号，如在在表达式 abc] 中，并将其作为字面值对待。此类还接受不匹配的括号，但对 +、? 和 * 不匹配元字符有严格限制；如果遇到它们，则抛出 PatternSyntaxException。

有关正则表达式构造行为更准确的描述，请参见《Mastering Regular Expressions, 2nd Edition》，该书由 Jeffrey E. F. Friedl、O'Reilly 和 Associates 合著，于 2002 年出版。

从以下版本开始：

1.4

另请参见：

String.split(String, int), String.split(String), 序列化表格

　　本文以作者对JVM的理解和自己的经验，对Java的初始化做一个比深入的说明，由于作者有水平限制，以及JDK各实现版本的变化，可能仍然有不少错误和缺点。欢迎行家高手赐教。

　　要深入了解Java初始化，我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行机制和堆栈跟踪是有效的手段。可惜的是，到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况。

　　<<Thinking in java>>(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:

　　以下译文原文:

　　可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。

　　我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字"<clinit>"和"<init>"。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?

　　"<clinit>"和"<init>"方法在哪里？这两个方法是实际存在而你又找不到的方法，也许正是这样才使得一些大师都犯晕。加上jdk实现上的一些BUG，如果没有深入了解，真的让人摸不着北。

　　现在科学体系有一个奇怪的现象，那么庞大的体系最初都是建立在一个假设的基础是，假设1是正确的，由此推导出2，再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设，我要确实证明"<clinit>"和"<init>"方法是真真实实的存在的：

 package debug;
 public class MyTest{
  static int i = 100/0;
  public static void main(String[] args){
   Ssytem.out.println("Hello,World!");
  }
 }

　　执行一下看看,这是jdk1.5的输出：

java.lang.ExceptionInInitializerError
Caused by: java.lang.ArithmeticException: / by zero
 at debug.MyTest.(Test.java:3)
Exception in thread "main" 

　　请注意，和其它方法调用时产生的异常一样，异常被定位于debug.MyTest的<clinit>.

　　再来看：

package debug;
public class Test {
  Test(){
      int i = 100 / 0;
  }
  public static void main(String[] args) {
    new Test();
  }
}
jdk1.5输入：
 Exception in thread "main" java.lang.ArithmeticException: / by zero
  at debug.Test.<init>(Test.java:4)
  at debug.Test.main(Test.java:7)

JVM并没有把异常定位在Test()构造方法中，而是在debug.Test.<init>。
　　当我们看到了这两个方法以后，我们再来详细讨论这两个“内置初始化方法”（我并不喜欢生造一些
　　非标准的术语，但我确实不知道如何规范地称呼他们）。
　　内置初始化方法是JVM在内部专门用于初始化的特有方法，而不是提供给程序员调用的方法，事实上“<>”这样的语法在源程序中你连编译都无法通过。这就说明，初始化是由JVM控制而不是让程序员来控制的。
类初始化方法：<clinit>
　　我没有从任何地方了解到<clinit>的cl是不是class的简写，但这个方法确实是用来对“类”进行初
　　始化的。换句话说它是用来初始化static上下文的。
　　在类装载（load）时，JVM会调用内置的<clinit>方法对类成员和静态初始化块进行初始化调用。它们的顺序按照源文件的原文顺序。
　　我们稍微增加两行static语句：
package debug;
public class Test {
  static int x = 0;
  static String s = "123";
  static {
    String s1 = "456";
    if(1==1)
    throw new RuntimeException();
  }
  public static void main(String[] args) {
    new Test();
  }
}
　　然后进行反编译：
javap -c debug.Test
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
static int x;
static java.lang.String s;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   return
public static void main(java.lang.String[]);
  Code:
   0:   new     #2; //class debug/Test
   3:   dup
   4:   invokespecial   #3; //Method "":()V
   7:   pop
   8:   return
static {};
  Code:
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."":()V
   19:  athrow
我们可以看到,类初始化正是按照源文件中定义的原文顺序进行。先是声明
  static  int x;
  static  java.lang.String s;
　　然后对int x和String s进行赋值：
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
　　执行初始化块的String s1 = "456";生成一个RuntimeException抛
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."":()V
   19:  athrow
　　要明白的是，"<clinit>"方法不仅是类初始化方法，而且也是接口初始化方法。并不是所以接口
　　的属性都是内联的，只有直接赋常量值的接口常量才会内联。而
　　[public static final] double d = Math.random()*100;
　　这样的表达式是需要计算的，在接口中就要由"<clinit>"方法来初始化。
下面我们再来看看实例初始化方法"<init>"
　　"<init>"用于对象创建时对对象进行初始化，当在HEAP中创建对象时，一旦在HEAP分配了空间。最先就会调用"<init>"方法。这个方法包括实例变量的赋值（声明不在其中）和初始化块，以及构造方法调用。如果有多个重载的构造方法，每个构造方法都会有一个对应的"<init>"方法。构造方法隐式或显示调用父类的构造方法前,总是先执行实例变量初始化和初始化块.同样，实例变量和初始化块的顺序也是按源文件的原文顺序执行，构造方法中的代码在最后执行：

package debug;
public class Test {
  int x = 0;
  String s = "123";
  {
    String s1 = "456";
    //if(1==1)
    //throw new RuntimeException();
  }
  public Test(){
    String ss = "789";
  }
  public static void main(String[] args) {
    new Test();
  }
}
javap -c debug.Test的结果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
int x;
java.lang.String s;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   iconst_0
   6:   putfield        #2; //Field x:I
   9:   aload_0
   10:  ldc     #3; //String 123
   12:  putfield        #4; //Field s:Ljava/lang/String;
   15:  ldc     #5; //String 456
   17:  astore_1
   18:  ldc     #6; //String 789
   20:  astore_1
   21:  return
public static void main(java.lang.String[]);
  Code:
   0:   new     #7; //class debug/Test
   3:   dup
   4:   invokespecial   #8; //Method "":()V
   7:   pop
   8:   return
}
　　如果在同一个类中，一个构造方法调用了另一个构造方法，那么对应的"<init>"方法就会调用另一
　　个"<init>"，但是实例变量和初始化块会被忽略，否则它们就会被多次执行。
package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
  
  public Test(){
    s1 = "s1";
  }
  public Test(String s){
    this();
    if(1==1) throw new Runtime();
  }
  String rt(String s){
    return s;
  }
  public static void main(String[] args) {
    new Test("");
  }
}
　　反编译的结果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;
java.lang.String s2;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  aload_0
   21:  ldc     #2; //String s1
   23:  putfield        #4; //Field s1:Ljava/lang/String;
   26:  return
public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."":()V
   11:  athrow
java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn
public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "":(Ljava/lang/String;)V
   9:   pop
   10:  return
}
　　我们看到，由于Test(String s)调用了Test();所以"<init>":(Ljava/lang/String;)V不再对
　　实例变量和初始化块进次初始化：
public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."":()V
   11:  athrow
　　而如果两个构造方法是相互独立的，则每个构造方法调用前都会执行实例变量和初始化块的调用：
package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
  {
    String s3 = "s3";
  }
  public Test() {
    s1 = "s1";
  }
  public Test(String s) {
    if (1 == 1) 
      throw new RuntimeException();
  }
  String rt(String s) {
    return s;
  }
  public static void main(String[] args) {
    new Test("");
  }
}
　　反编译的结果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;
java.lang.String s2;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_1
   23:  aload_0
   24:  ldc     #2; //String s1
   26:  putfield        #4; //Field s1:Ljava/lang/String;
   29:  return
public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_2
   23:  new     #8; //class java/lang/RuntimeException
   26:  dup
   27:  invokespecial   #9; //Method java/lang/RuntimeException."":()V
   30:  athrow
java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn
public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "":(Ljava/lang/String;)V
   9:   pop
   10:  return
}
　　明白了上面这些知识,我们来做一个小测试吧:
public class Test2 extends Test1{
 {
  System.out.print("1");
 }
 Test2(){
  System.out.print("2");
 }
 static{
  System.out.print("3");
 }
 {
  System.out.print("4");
 }
 public static void main(String[] args) {
  new Test2();
 }
}
class Test1 {
 Test1(){
  System.out.print("5"); 
 }
 static{
  System.out.print("6");
 }
}
　　试试看能清楚打印的顺序吗?如果没有new Test2()将打印什么?

作者:axman  专栏:http://blog.csdn.net/axman/