正则表达式
1、 正则表达式可以方便的对数据进行匹配，可以执行更加复杂的字符串验证、拆分、替换功能等。
Eg ：现在判断一个字符串是不是由数字组成？
A ：不使用正则表达式
public class RegexDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = "1234567890";//此字符串由数字组成
boolean flag = true;//定义标志变量
//不使用正则的基本思路是：将字符串转换为字符数组，之后再依次进行判断
char[] c = str.toCharArray();//将字符串转换为字符数组
for(int i=0;i<c.length;i++){
if(c[i]<'0' || c[i]>'9'){ //如果满足条件，说明不是由数字组成
flag = false;
break;
}
}
if(flag){
System.out.println("yes!由数字组成");
}else{
System.out.println("不是由数字组成！");
}
}
}
运行结果截图：
问题：基本思路是将字符串拆分为字符数字之后，一个个进行验证，如果遇到更加复杂的情况呢？
B ： 使用正则表达式
import java.util.regex.Pattern;
public class RegexDemo02 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = "1234567890";
if(Pattern.compile("[0-9]+").matcher(str).matches()){ //使用正则表达式
System.out.println("是由数字组成！");
}else{
System.out.println("不是由数字组成！");
}
}
}
运行结果截图：
2、 正则： Pattern 类、 Matcher 类
正则的两个核心操作类：
A
：
public final class
Matcher
extends
Object
implements
MatchResult
B: public final class
Pattern
extends
Object
implements
Serializable
3、正则表达式的编译表示形式
指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 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 类的实例用于此目的则不安全。
1、 常用的正则规则：
|
构造 |
匹配 |
|
|
|
|
字符 |
|
|
x |
字符 x |
|
\\ |
反斜线字符 |
|
\0 n |
带有八进制值 0 的字符 n (0<= n <=7) |
|
\0 nn |
带有八进制值 0 的字符 nn (0<= n <=7) |
|
\0 mnn |
带有八进制值 0 的字符 mnn （0<= m <=3、0<= n <=7） |
|
\x hh |
带有十六进制值0x 的字符 hh |
|
\u hhhh |
带有十六进制值0x 的字符 hhhh |
|
\t |
制表符 ('\u0009') |
|
\n |
新行（换行）符 ('\u000A') |
|
\r |
回车符 ('\u000D') |
|
\f |
换页符 ('\u000C') |
|
\a |
报警 (bell) 符 ('\u0007') |
|
\e |
转义符 ('\u001B') |
|
\c x |
对应于 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 |
任何匹配的 n th 捕获组 |
|
|
|
|
引用 |
|
|
\ |
Nothing，但是引用以下字符 |
|
\Q |
Nothing，但是引用所有字符，直到 \E |
|
\E |
Nothing，但是结束从 \Q 开始的引用 |
|
|
|
|
特殊构造（非捕获） |
|
|
(?: X ) |
X ，作为非捕获组 |
|
(?idmsux-idmsux) |
|
|
(?idmsux-idmsux: X ) |
|
|
(?= X ) |
X ，通过零宽度的正 lookahead |
|
(?! X ) |
X ，通过零宽度的负 lookahead |
|
(?<= X ) |
X ，通过零宽度的正 lookbehind |
|
(?<! X ) |
X ，通过零宽度的负 lookbehind |
|
(?> X ) |
X ，作为独立的非捕获组 |
4、字符类
字符类可以出现在其他字符类中，并且可以包含并集运算符（隐式）和交集运算符 (&&)。并集运算符表示至少包含其某个操作数类中所有字符的类。交集运算符表示包含同时位于其两个操作数类中所有字符的类。
字符类运算符的优先级如下所示，按从最高到最低的顺序排列：
|
1 |
字面值转义 |
\x |
|
2 |
分组 |
[...] |
|
3 |
范围 |
a-z |
|
4 |
并集 |
[a-e][i-u] |
|
5 |
交集 |
[a-z&&[aeiou]] |
