java正则 特定值 java正则对象

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*$