java 正则表达式用法(1)

//模式类：用来表示一个编译过的正则表达式
import java.util.regex.Pattern;
//匹配类：用模式匹配一个字符串所表达的抽象结果
import java.util.regex.Matcher;

/*
正则表达式通用匹配符号：
.     匹配任何单个字符
^xx   在开头匹配正则xx
xx$   在结尾匹配正则xx
[ab]  能够匹配字母a或b
[^ab] 匹配除了a,b或c之外的任意字符
a|b   匹配a或b

正则表达式元字符：
\d    任意数字，等同于[0-9]
\D    任意非数字，等同于[^0-9]
\s    任意空白字符，等同于[\t\n\x0B\f\r]
\S    任意非空白字符，等同于[^\s]
\w    任意英文字符，等同于[a-zA-Z_0-9]
\W    任意非英文字符，等同于[^\w]
\b    单词边界
\B    非单词边界

正则表达式量词：
贪婪    勉强     侵占     说明
x?      x??      x?+      x出现0次或1次
x*      x*?      x*+      x出现0次或多次
x+      x+?      x++      x出现1次或多次
x{n}    x{n}?    x{n}+    x正好出现n次
x{n,}   x{n,}?   x{n,}+   x至少出现n次
x{n,m}  x{n,m}?  x{n,m}+  x出现至少n次但不多于m次
区别：
1、贪婪：最长匹配，读入整个输入的字符串，来优先尝试第一次匹配，如果第一次尝试匹配（对于整个输入的字符串）失败，匹配器会通过回退整个字符串的一个字符再一次进行尝试，不断地进行处理直到找
到一个匹配，或者左边没有更多的字符来用于回退了。赖于在表达式中使用的量词，最终它将尝试地靠着1 或 0 个字符的匹配。
2、勉强：最少匹配，采用相反的途径：从输入字符串的开始处开始，因此每次勉强地吞噬一个字符来寻找匹配，最终它们会尝试整个输入的字符串。
3、侵占：始终是吞掉整个输入的字符串，尝试着一次（仅有一次）匹配。不像贪婪量词那样，侵占量词绝不会回退，即使这样做是允许全部的匹配成功。

*/

public class RegexDemo {
public static void main(String arg[]) {

//快速检查模式是否表示给定的输入字符串
System.out.println(Pattern.matches("\\d","123"));
System.out.println(Pattern.matches("\\d*","123"));
/*
false
true
*/

//判断字符串是不是数字
Pattern p1 = Pattern.compile("^[1-9]+\\d*$");
Matcher m1 = p1.matcher("123");
System.out.println(m1.matches());
/*
true
*/

//分割字符串
Pattern p2 = Pattern.compile("[,;]+");
String[] items = p2.split("a,b,c;1,2");
for(String s : items) {
System.out.println(s);
}
/*
a
b
c
1
2
*/

Pattern p3 = Pattern.compile("\\d");
Matcher m3 = p3.matcher("abc123def456hgx");
//替换第一个符合正则的字符为指定字符
System.out.println(m3.replaceFirst("%"));
//替换所有符合正则的字符为指定字符
System.out.println(m3.replaceAll("%"));
/*
abc%23def456hgx
abc%%%def%%%hgx
*/

//查找匹配的字符：贪婪
Pattern p4 = Pattern.compile("X+");
Matcher m4 = p4.matcher("X XX XXX");
while(m4.find()){
System.out.println(m4.group());
}
/*
X
XX
XXX
*/
//查找匹配的字符：勉强
Pattern p5 = Pattern.compile("X+?");
Matcher m5 = p5.matcher("X XX XXX");
while(m5.find()){
System.out.println(m5.group());
}
/*
X
X
X
X
X
X
*/
//查找匹配的字符：侵占
Pattern p6 = Pattern.compile("X++");
Matcher m6 = p6.matcher("X XX XXX");
while(m6.find()){
System.out.println(m6.group());
}
/*
X
XX
XXX
*/

}
}