java.util.regex.Pattern类指正则表达式的编译表示形式。即将你的正则表达式字符串编译成java正则表达式对象。所有的正则表达式字符串在使用前都必须先编译成Pattern类的实例。然后通过这个Pattern对象创建一个Matcher对象，根据你定义的正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 因此，典型的调用顺序如下：// 第一步：将你自定义的正则表达式(java.*)编译成java正则表达式对象

Pattern pattern = Pattern.compile("java.*");

// 第二步：解释自定义的正则表达式(java.*)对字符串(javascript)进行匹配

Matcher macther = pattern.matcher("javascript");

// 第三步：尝试将整个字符串(javascript)与模式进行匹配匹配

boolean isMacher = macther.matches();

如果仅使用一次的正则表达式，可以方便地通过Pattern类定义matches方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句如下：boolean b = Pattern.matches("java.*", "javascript");

该语句等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。 注意：Pattern类的实例是不可变的，可以在多个并发线程下安全使用。

使用正则表达式之前必须先要了解正则表达式的常用语法，由于正则表达式在不同的语言中实现存在一定的差异，下面将列出在Java对正则表达式的定义：

构造      匹配

x           字符 x

\\          反斜线字符

\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 的控制符

字符类

[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](减去)

预定义字符类

. 任何字符(与行结束符可能匹配也可能不匹配)

\d 数字：[0-9]

\D 非数字： [^0-9]

\s 空白字符：[ \t\n\x0B\f\r]

\S 非空白字符：[^\s]

\w 单词字符：[a-zA-Z_0-9]

\W 非单词字符：[^\w]

POSIX 字符类(仅 US-ASCII)

\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]

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()

Unicode 块和类别的类

\p{InGreek} Greek 块(简单块)中的字符

\p{Lu} 大写字母(简单类别)

\p{Sc} 货币符号

\P{InGreek} 所有字符，Greek 块中的除外(否定)

[\p{L}&&[^\p{Lu}]]  所有字母，大写字母除外(减去)

边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

\B 非单词边界

\A 输入的开头

\G 上一个匹配的结尾

\Z 输入的结尾，仅用于最后的结束符(如果有的话)

\z 输入的结尾

Greedy 数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

Reluctant 数量词

X?? X，一次或一次也没有

X*? X，零次或多次

X+? X，一次或多次

X{n}? X，恰好 n 次

X{n,}? X，至少 n 次

X{n,m}? X，至少 n 次，但是不超过 m 次

Possessive 数量词

X?+ X，一次或一次也没有

X*+ X，零次或多次

X++ X，一次或多次

X{n}+ X，恰好 n 次

X{n,}+ X，至少 n 次

X{n,m}+ X，至少 n 次，但是不超过 m 次

Logical 运算符

XY X 后跟 Y

X|Y X 或 Y

(X) X，作为捕获组

Back 引用

\n 任何匹配的 nth 捕获组

引用

\ Nothing，但是引用以下字符

\Q Nothing，但是引用所有字符，直到 \E

\E Nothing，但是结束从 \Q 开始的引用

特殊构造(非捕获)

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

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

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

的非捕获组  (?=X) X，通过零宽度的正 lookahead

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

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

(?

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

package com.bug315;

import java.util.Arrays;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

* java正则表达式中的Pattern类

* @author hx

*

*/

public class PatternTest01 {

public static void main(String[] args) {

// 定义正则表达式(只匹配https://www.***.com类似网址)

String patternStr = "^\\s*http\\:\\/\\/w{3}\\..{2,}\\.com\\s*$";

String sourceStr1 = " https://www.hxstrive.com    ";

String sourceStr2 = "HTTP://www.bug315.cOm     ";

/**

* 使用默认标志将指定的正则表达式编译为Pattern对象

*/

Pattern pattern01 = Pattern.compile(patternStr);

Matcher macther01 = pattern01.matcher(sourceStr1);

Matcher macther02 = pattern01.matcher(sourceStr2);

// true

System.out.println("macther01.matches()=" + macther01.matches() );

// false (因为HTTP是大写的)

System.out.println("macther02.matches()=" + macther02.matches() );

/**

* 使用指定的标志编译指定的正则表达式

* Pattern.CASE_INSENSITIVE 表示启用不区分大小写的匹配。更多请参考API

* Pattern.MULTILINE 表示启用多行模式

*/

Pattern pattern12 = Pattern.compile(patternStr,

Pattern.CASE_INSENSITIVE + Pattern.MULTILINE);

Matcher macther11 = pattern12.matcher(sourceStr1);

Matcher macther12 = pattern12.matcher(sourceStr2);

// true

System.out.println("macther11.matches()=" + macther11.matches() );

// true

System.out.println("macther12.matches()=" + macther12.matches() );

// 返回在compile设置的flag值，这里返回的是10(CASE_INSENSITIVE=2，MULTILINE=8)2+8=10

System.out.println(pattern12.flags());

/**

* 使用pattern的matches方法进行匹配，该方法建议在模式不复用的情况下使用。

* 因为这种方式非常便捷，可以将上面的三个步骤转换成一个步骤。

*/

boolean isMacher01 = Pattern.matches(patternStr, sourceStr1);

boolean isMacher02 = Pattern.matches(patternStr, sourceStr2);

System.out.println("isMacher01=" + isMacher01);

System.out.println("isMacher02=" + isMacher02);

/**

* 使用Pattern的split方法对字符序列进行按照表达式进行分割

* 例：使用|^|对字符串进行分割

*/

Pattern pattern03 = Pattern.compile("\\|\\^\\|");

String[] split01 = pattern03.split("java|^|c++|^|php");

// 设定使用指定分隔符分割2次

String[] split02 = pattern03.split("java|^|c++|^|php", 2);

System.out.println( Arrays.toString(split01) );

System.out.println( Arrays.toString(split02) );

/**

* 获取输入的正则表达式模式

*/

Pattern pattern04 = Pattern.compile(patternStr);

System.out.println(pattern04.pattern());

System.out.println(pattern04.toString());

}

}

输出结果：

macther01.matches()=true

macther02.matches()=false

macther11.matches()=true

macther12.matches()=true

10

isMacher01=true

isMacher02=false

[java, c++, php]

[java, c++|^|php]

^\s*http\:\/\/w{3}\..{2,}\.com\s*$

^\s*http\:\/\/w{3}\..{2,}\.com\s*$