黑马程序员——java学习15（毕25）——正则表达式

 1 package learn;
 2 
 3 /*
 4 * 获取
 5 */
 6 import java.util.regex.*;
 7 
 8 class RegexDemo2
 9 {
10     public static void main(String[] args) 
11     {
12         get();
13     }
14     public static void get()
15     {
16         String str = "ming tian jiu yao fang jia le ,dajia .";
17         System.out.println(str);
18         String regex = "\b[a-z]{3}\b";
19 
20         //将规则封装成对象。
21         Pattern p = Pattern.compile(regex);
22 
23         //让正则对象和要作用的字符串相关联。获取匹配器对象。
24         Matcher m  = p.matcher(str);
25 
26         //System.out.println(m.matches());//其实String类中的matches方法。用的就是Pattern和Matcher对象来完成的。
27                                         //只不过被String的方法封装后，用起来较为简单。但是功能却单一。
28         
29         //boolean b = m.find();
30 //        System.out.println(b);
31 //        System.out.println(m.group());
32         while(m.find())
33         {
34             //使用group方法获取匹配后的结果。
35             System.out.println(m.group());
36             //start()和end()方法的返回值分别表示匹配后的结果在字符串上的角标位置。
37             System.out.println(m.start()+"，"+m.end());
38         }
39     }
40 }

字符 
x 字符 x 
\ 反斜线字符 
 n 带有八进制值 0 的字符 n (0 <= n <= 7) 
 nn 带有八进制值 0 的字符 nn (0 <= n <= 7) 
 mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7） 
xhh 带有十六进制值 0x 的字符 hh 
uhhhh 带有十六进制值 0x 的字符 hhhh 
	 制表符 ('u0009') 

 新行（换行）符 ('u000A') 

 回车符 ('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 空白字符：[ 	
x0Bf
] 
S 非空白字符：[^s] 
w 单词字符：[a-zA-Z_0-9] 
W 非单词字符：[^w] 

边界匹配器 
^ 行的开头 
$ 行的结尾 
 单词边界 
B 非单词边界 
A 输入的开头 
G 上一个匹配的结尾 
 输入的结尾，仅用于最后的结束符（如果有的话） 
z 输入的结尾 
  
Greedy 数量词 
X? X，一次或一次也没有 
X* X，零次或多次 
X+ X，一次或多次 
X{n} X，恰好 n 次 
X{n,} X，至少 n 次 
X{n,m} X，至少 n 次，但是不超过 m 次 

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

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

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