黑马程序员_Java基础_正则表达式

一、正则表达式(特点)

正则表达式：符合一定规则的表达式。

特点：用一些特定的符号来表示一些代码操作，这样就简化书写。

所以学习正则表达式就是在学习一些特殊符号的使用。

作用：用于操作字符串。

好处：可以简化对字符串的复杂操作。

弊端：符号定义越多，正则越长，阅读性越差。

先来看一个示例：

[java]  view plain copy

1. /* 
2. 示例： 
3. */  
4. class RegexDemo   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         checkQQ_1();  
9.         checkQQ_2();  
10.     }  
11.   
12.     /* 
13.     对QQ号码进行校验： 
14.     要求：5-15位。0不能开头，只能是数字。 
15.     */  
16.       
17.     public static void checkQQ_2()//使用正则表达式  
18.     {  
19.         String qq="1a234576";  
20.               
21.         String regex="[1-9][0-9]{4,14}";  
22.   
23.         boolean flag=qq.matches(regex);  
24.   
25.         if(flag)  
26.         {     
27.             System.out.println("QQ:"+qq);  
28.         }  
29.         else  
30.         {  
31.             System.out.println("输入不合法");  
32.         }  
33.     }  
34.   
35.   
36.     public static void checkQQ_1()//这种方式使用String类中的方法，进行组合完成了需求。但是代码国语复杂。  
37.     {  
38.         String qq="123456";  
39.         int len=qq.length();  
40.         if(len>=5 && len<=15)  
41.         {  
42.             if(!qq.startsWith("0"))  
43.             {  
44.                 try  
45.                 {  
46.                     Long l=Long.parseLong(qq);  
47.                     System.out.println("QQ:"+l);  
48.                 }  
49.                 catch (NumberFormatException e)  
50.                 {  
51.                     System.out.println("出现非法字符");  
52.                 }     
53.   
54.                 /* 
55.                 char[] arr=qq.toCharArray(); 
56.                 boolean flag=true; 
57.                 for(int i=0;i<arr.length;i++) 
58.                 { 
59.                     if(!(arr[i]>='0' && arr[i]<='9')) 
60.                     { 
61.                         flag=false; 
62.                         break; 
63.                     } 
64.                 } 
65.  
66.                 if(flag) 
67.                 { 
68.                     System.out.println("qq:"+qq); 
69.                 } 
70.                 else 
71.                 { 
72.                     System.out.println("出现非法字符"); 
73.                 } 
74.  
75.                 */  
76.             }  
77.             else  
78.             {  
79.                 System.out.println("不可以以0开头");  
80.             }  
81.         }  
82.         else  
83.         {  
84.             System.out.println("长度错误。");  
85.         }  
86.     }  
87. }  

二、正则表达式(匹配)

[java]  view plain copy

1. /* 
2. 具体操作功能： 
3. 1.匹配。public boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。 
4. */  
5. class RegexDemo2   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         checkTel();  
10.     }  
11.   
12.     public static void checkTel()//手机号码段只有 187******** 150******** 178********  
13.     {  
14.         String str1="18712334567";  
15.         String str2="10012334567";  
16.         String reg="1[578]\\d{9}";  
17.         System.out.println(str1.matches(reg));  
18.         System.out.println(str2.matches(reg));  
19.     }  
20.       
21. }  

三、正则表达式(切割)

[java]  view plain copy

1. /* 
2. 具体操作功能： 
3. 2.切割。public String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。 
4. */  
5. class RegexDemo3   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         splitDemo("zhangsan   lisi  wangwu        zhaoliu"," +");//切割包含多个空格的  
10.         System.out.println();  
11.         splitDemo("zhangsan.lisi.wangwu.zhaoliu","\\.");//切割包含.的  
12.         System.out.println();  
13.         splitDemo("c:\\abc\\a.txt","\\\\");//切割目录  
14.         System.out.println();  
15.         splitDemo("asdfassssdjfkzzzzzzodff","(.)\\1+");/* 
16.  
17.                                                         按照叠词完成切割，为了可以让规则的结果被重用， 
18.                                                         可以将规则封装成一个组，用()完成。组的出现都有编号， 
19.                                                         从1开始，想要使用自己已有的组，可以通过\n(n是组的编号) 
20.                                                         的形式来获取。 
21.          
22.                                                        */  
23.           
24.     }  
25.   
26.     public static void splitDemo(String str,String reg)  
27.     {  
28.         String[] arr=str.split(reg);  
29.         for(String s:arr)  
30.         {  
31.             System.out.println(s);  
32.         }  
33.     }  
34.       
35. }  

四、正则表达式(替换)

[java]  view plain copy

1. /* 
2. 具体操作功能： 
3. 3.替换。public String replaceAll(String regex,String replacement)： 
4.         使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。  
5. */  
6. class RegexDemo4  
7. {  
8.     public static void main(String[] args)   
9.     {  
10.         String str1="asdvfsa123124356asjdf4334543234iupok43234123fsa";  
11.         replaceAllDemo(str1,"\\d{5,}","#");//将字符串中的数字长度大于5的子段替换成#  
12.   
13.         String str2="asdfssswqqqfsdffff";//将重叠的字符替换成单个字母。例如： ssss----->s  
14.         replaceAllDemo(str2,"(.)\\1+","$1");  
15.   
16.           
17.     }  
18.   
19.     public static void replaceAllDemo(String str,String reg,String newStr)  
20.     {  
21.         str=str.replaceAll(reg,newStr);  
22.         System.out.println(str);  
23.     }  
24.       
25. }  

五、正则表达式(获取)

[java]  view plain copy

1. /* 
2. 具体操作功能： 
3. 4.获取：将字符串中的符合规则的子串取出。 
4.  
5. 步骤： 
6. 1.将正则表达式封装成对象。 
7. 2.让正则对象和要操作的字符串相关联。 
8. 3.关联后，获取正则匹配引擎。 
9. 4.通过引擎对符合规则的字串进行操作，例如取出。 
10.  
11. */  
12. import java.util.regex.*;  
13.   
14. class RegexDemo5  
15. {  
16.     public static void main(String[] args)   
17.     {     
18.         getDemo();  
19.     }  
20.   
21.     public static void getDemo()  
22.     {  
23.         String str="java ji chu";  
24.   
25.         String reg="\\b[a-z]{3}\\b";  
26.           
27.         //将规则封装成对象。  
28.         Pattern p=Pattern.compile(reg);  
29.   
30.         //让正则对象和要作用的字符串相关联，获取匹配器对象。  
31.         Matcher m=p.matcher(str);  
32.   
33.         //System.out.println(m.matches());/*String类中的matches方法用的就是Pattern和Matcher对象来完成的*/  
34.                                          /*只不过被String的方法封装后，用起来较为简单，但功能单一。*/  
35.           
36.   
37.   
38.         //System.out.println("matches:"+m.matches());//注意：同一个匹配器用的同一个指针。  
39.   
40.         while(m.find())//将规则作用到字符串上，并进行符合规则的子串查找。  
41.         {  
42.             System.out.println(m.group());//用于获取匹配后结果。  
43.         }  
44.     }     
45. }  

六、正则表达式(练习1)

[java]  view plain copy

1. /* 
2. 需求： 
3. 将下列字符串转成：我要学编程 
4.  
5. 用四种功能的哪一个呢？或哪几个呢？ 
6. 思路： 
7. 1.如果只想知道该字符是否是对是错，使用匹配。 
8. 2.想要将已有的字符串变成另一个字符串，替换。 
9. 3.想要按照自定的方式将字符串编程多个字符串，切割。获取规则以外的子串。 
10. 4.想要拿到符合要求的字符串的字串，获取。获取符合规则的子串。 
11.  
12. */  
13. class RegexText   
14. {  
15.     public static void main(String[] args)   
16.     {  
17.         test_1();  
18.     }  
19.     public static void test_1()  
20.     {  
21.         String str="我我我我.....我我我我..要..要要要要要...要要要要.学.学.学学学.编.编..编编编.程.程程程.程";  
22.   
23.         /* 
24.         将已有字符串编程另一个字符串，使用替换功能。 
25.  
26.         1.可以现将.去掉 
27.         2.再将多个重复的内容变成单个内容。 
28.  
29.         */  
30.   
31.         str=str.replaceAll("\\.+","");  
32.         System.out.println(str);  
33.   
34.         str=str.replaceAll("(.)\\1+","$1");  
35.         System.out.println(str);  
36.     }  
37. }  

七、正则表达式(练习2)

[java]  view plain copy

1. /* 
2. 192.168.1.1 102.49.23.013 10.10.10.10 2.2.2.8 8.109.90.30 
3. 将ip地址进行地址段顺序排序。 
4.  
5. 还按照字符串自然顺序，只要让它们每一段都是3位即可。 
6. 1.按照每一段需要的对多的0进行补齐，那么每一段就会至少保证有3位。 
7. 2.将每一段只保留3位。这样，所有的ip地址都是每一段3位。 
8. */  
9.   
10. import java.util.*;  
11. class RegexText2  
12. {  
13.     public static void main(String[] args)   
14.     {  
15.         ipSort();  
16.         checkMail();  
17.     }  
18.     public static void ipSort()  
19.     {  
20.         String ip="192.168.1.1 102.49.23.013 10.10.10.10 2.2.2.8 8.109.90.30";  
21.   
22.         ip=ip.replaceAll("(\\d+)","00$1");  
23.         System.out.println(ip);  
24.   
25.         ip=ip.replaceAll("0*(\\d{3})","$1");  
26.         System.out.println(ip);  
27.   
28.         String[] arr=ip.split(" ");  
29.   
30.         TreeSet<String> ts=new TreeSet<String>();  
31.         for(String s:arr)  
32.         {  
33.             ts.add(s);  
34.         }  
35.   
36.         System.out.println();  
37.         for(String s:ts)  
38.         {  
39.             System.out.println(s.replaceAll("0*(\\d+)","$1"));  
40.         }  
41.     }  
42.     public static void checkMail()  
43.     {  
44.         String mail="abc@sohu.com.cn";  
45.   
46.         String reg="[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";//精确匹配  
47.         //reg="\\w+@\\w+(\\.\\w+){1,3}";//相对不太精确的匹配   1@2.1 就没意义了  
48.   
49.         System.out.println();  
50.         System.out.println(mail.matches(reg));  
51.     }  
52. }  

八、正则表达式(网页爬虫)

网页：

[html]  view plain copy

1. <html>  
2.     <head>  
3.         <title>  
4.         邮件获取  
5.         </title>  
6.     </head>  
7.   
8.     <body>  
9.         <div>  
10.         djkfjalksdjflkdsajf zhangsan@126.com asdfaewfsdaf;wefaskjfdalkdsf  
11.         alewjflkadsg lisi@sohu.com aslkjf;lsakdfj;oiewajflakjdsg;lkajdsgaaldskfljklj   
12.         fdjglkadjglkasdjf;lkjdsaf;lksaef ;lrsjg;;rajg aslkd;kdjflkjlsad  
13.         arewjgalkfdjg;lkfdajg; w wangwu@126.com eokflasjglkajfd;glaijdg;  
14.         welkjliewajugijfdalkg arj;lewaoigfla  
15.   
16.         </div>  
17.     </body>  
18. </html>  

[java]  view plain copy

1. /* 
2. 网页爬虫（蜘蛛）。 
3.  
4. */  
5. import java.net.*;  
6. import java.io.*;  
7. import java.util.regex.*;  
8. class RegexText3    
9. {  
10.     public static void main(String[] args)throws Exception   
11.     {  
12.         getMails();  
13.     }  
14.     public static void getMails()throws Exception  
15.     {  
16.         /* 
17.         获取邮件地址。使用Pattern Matcher 
18.         */  
19.   
20.         URL url=new URL("http://172.16.56.254:8080/myweb/mail.html");  
21.   
22.         URLConnection conn=url.openConnection();  
23.   
24.         BufferedReader bufrIn=new BufferedReader(new InputStreamReader(conn.getInputStream()));  
25.   
26.         String line=null;  
27.           
28.         String mailreg="\\w+@\\w+(\\.\\w+){1,3}";  
29.         Pattern p=Pattern.compile(mailreg);  
30.   
31.         while((line=bufrIn.readLine())!=null)  
32.         {  
33.             Matcher m=p.matcher(line);  
34.             while(m.find())  
35.             {  
36.                 System.out.println(m.group());  
37.             }  
38.         }  
39.     }  
40. }