黑马程序员JAVA笔记10--正则

------- android培训、java培训、期待与您交流！ ----------

正则

    正则表达式常用构造摘要
    字符类 
    [abc] a、b 或 c（简单类） 
    [^abc] 任何字符，除了 a、b 或 c（否定） 
    [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） 

    预定义字符类 
    . 任何字符（与行结束符可能匹配也可能不匹配） 
    \d 数字：[0-9] 
    \D 非数字： [^0-9] 
    \s 空白字符：[ \t\n\x0B\f\r] 
    \S 非空白字符：[^\s] 
    \w 单词字符：[a-zA-Z_0-9] 
    \W 非单词字符：[^\w] 

    Greedy 数量词 
    X?       X，一次或一次也没有 
    X*       X，零次或多次 
    X+      X，一次或多次 
    X{n}     X，恰好 n 次 
    X{n,}    X，至少 n 次 
    X{n,m} X，至少 n 次，但是不超过 m 次 

    边界匹配器 
    ^ 行的开头 
    $ 行的结尾 
    \b 单词边界 
    \B 非单词边界 
    \A 输入的开头 
    \G 上一个匹配的结尾 
    \Z 输入的结尾，仅用于最后的结束符（如果有的话） 
    \z 输入的结尾 

    正则表达式常见功能：匹配、切割、替换、获取

    示例：

1. import java.util.regex.Matcher;
2. import java.util.regex.Pattern;
3. 
4. public class RegexDemo
5. {
6.         public static void main(String[] args){
7.                 functionDemo_1();
8.                 System.out.println("------------------------");
9.                 functionDemo_2();
10.                 System.out.println("------------------------");
11.                 functionDemo_3();
12.                 System.out.println("------------------------");
13.                 functionDemo_4();
14.                 System.out.println("------------------------");
15.                 functionDemo_5();
16.                 System.out.println("------------------------");
17.                 functionDemo_6();
18.                 System.out.println("------------------------");
19.                 functionDemo_7();
20.         }
21. 
22.         /*
23.          * 正则表达式对字符串的常见操作
24.          * 1. 匹配
25.          *                其实使用的就是String类中的matches方法。
26.          *
27.          * 2. 切割
28.          *                其实使用的就是String类中的split方法。
29.          * 
30.          * 3. 替换
31.          *
32.          * 4. 获取
33.          */
34. 
35.          /*
36.           * 演示匹配
37.           */
38.         public static void functionDemo_1(){
39.                 //匹配手机号码是否正确
40.                 String tel = "15800001111";
41. 
42.                 String regex = "1[358]\\d{9}";
43. 
44.                 boolean b = tel.matches(regex);
45. 
46.                 System.out.println(tel + ":" + b);
47.         }
48. 
49.          /*
50.           * 演示切割
51.           */
52.         public static void functionDemo_2(){
53.                 String str = "zhangsan      xiaoqiang             zhaoliu";
54. 
55.                 String[] names = str.split(" +");
56. 
57.                 for(String name : names){
58.                         System.out.println(name);
59.                 }
60.         }
61. 
62.         public static void functionDemo_3(){
63.                 String str = "zhangsan.xiaoqiang.zhaoliu";
64. 
65.                 String[] names = str.split("\\.");
66. 
67.                 for(String name : names){
68.                         System.out.println(name);
69.                 }
70.         }
71. 
72.         /*
73.          * 在表达式 ((A)(B(C))) 中，存在四个这样的组： 
74.          * 1 ((A)(B(C))) 
75.          * 2 \A 
76.          * 3 (B(C)) 
77.          * 4 (C) 
78.          * 组零始终代表整个表达式。 
79.          */
80.         public static void functionDemo_4(){
81.                 String str = "zhangsanttttxiaoqiangmmmmmzhaoliu";
82. 
83.                 //(.)表示一组，\\1+表示与第1组相同的出现1次以上
84.                 String[] names = str.split("(.)\\1+");
85. 
86.                 for(String name : names){
87.                         System.out.println(name);
88.                 }
89.         }
90. 
91.          /*
92.           * 演示替换
93.           */
94.         public static void functionDemo_5(){
95.                 String str = "zhangsanttttxiaoqiangmmmmmzhaoliu";
96. 
97.                 //$表示前一个参数的第一组
98.                 str = str.replaceAll("(.)\\1+","$1");
99. 
100.                 System.out.println(str);
101.         }
102. 
103.         public static void functionDemo_6(){
104.                 String str = "15800001111";
105. 
106.                 str = str.replaceAll("(\\d{3})(\\d{4})(\\d{4})","$1****$2");
107. 
108.                 System.out.println(str);
109.         }
110. 
111.         /*
112.           * 演示获取
113.           * 将正则规则进行对象的封装。
114.           * Pattern p = Pattern.compile("a*b");
115.           * 通过正则对象的matcher方法字符串相关联。获取要对字符串操作的匹配器对象Matcher。
116.           * boolean b = m.matches();
117.           */
118.         public static void functionDemo_7(){
119.                 String str = "da jia hao,ming tian bu fang jia";
120. 
121.                 // \\b表示单词边界
122.                 String regex = "\\b[a-z]{3}\\b";
123. 
124.                 //1. 将正则封装成对象
125.                 Pattern p = Pattern.compile(regex);
126. 
127.                 //2. 通过正则对象获取匹配器对象
128.                 Matcher m = p.matcher(str);
129. 
130.                 //使用Matcher对象的方法对字符串进行操作。
131.                 //既然要获取三个字母组成的单词。
132.                 //查找：find();
133.                 while(m.find()){
134.                         System.out.println(m.group());//获取匹配的子序列
135.                         System.out.println(m.start() + ":" + m.end());
136.                 }
137.         }
138. }

注释：
    1、Pattern类为正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。