(二十) 正则表达式 (基本用法 以及 爬虫) (118)

 目录 :          1 ) . 正则表达式(概述)
2 ) . 正则表达式(常见的规则)
3 ) . 正则表达式(常见的功能 -匹配)
4 ) . 正则表达式(常见的功能 -切割)
5 ).  正则表达式(常见的功能 - 替换)
6 ).  正则表达式( 常见的功能 -获取 )
7 ).  正则表达式(练习  -1 )
8 ).  正则表达式(练习  -2 )
9 ).  正则表达式(练习 - 3)
10  ). 正则表达式(练习 -4 爬虫)
11 ). 总结

     一.  正则表达式(概述)
1 ) . 简述 : 
1.1  解说 : 正则 --> 正确的规则
1.2 功能 :  用于操作字符串数据 
1.3 使用 : 通过向string类的方法matches中传入特定的的符号来判断是否符合标准,这些特定的符号就是 正则  表达式
1.4 优势 : 简化字符判断时的书写
1.5 劣势 : 阅读性较差
2 ) . 案例 : 
package cn.ittext.day01;/*** @author  winter* @Date    2018年4月1日下午9:43:58* @tel    1394869214@qq.com* @version 1.0* @describe 认识正则以及qq正则示例*/public class RegexQQ01 {       public static void main(String[] args)       {                          String qq = "123413";             /**              *              * 需求: qq号验证              *              * 要求 : 长度 5-15 , 开头不能为 0 , 全数字              *              * [1] 原始验证              *              * [2] 正则验证              */                          //     regexQQ(qq); //原始验证                          //正则表达式             String regex ="[1-9][1-9]{4,14}";  //该正则表示 开头数字 1-9 ,后边 的 可以有 4-14位数,并且都是 1-9             //正则验证             boolean matches = qq.matches(regex);             //验证结果只有 true 与flase             sop(matches);                                 }       //校验QQ的方法 -->原始       public static void regexQQ(String qq)       {             int length = qq.length();                          if(length>5&length<15)             {                    if(!(qq.startsWith("0")))                    {                           long parseLong =0 ;                           try {                                 parseLong = Long.parseLong(qq);                                 sop(parseLong+"正确");                           }catch(NumberFormatException e)                           {                                 sop("非法字符");                           }                    }else                    {                           sop(qq+":不可用0开头 ");                    }             }             else             {                    sop(qq+": 长度不正确");             }       }       public static void sop(Object obj) {             System.out.println(obj);       }}  

 小结 :  
           1.  通过正则验证大大简化了 string字符串类型的规则验证的 代码               
     二. 正则表达式(常见的规则)

1 ) . 常用字符规则
1.1 [abc] --> 指字符串中的某一位只能是 abc 其中的 字母
1.2 [^abc] --> 指字符串中的某一位不允许是 abc 其中的 字母
1.3 [a-zA-Z] -->指字符串中的某一个允许是小写a-z ,大写 A-Z, 也就是所有大小写字母
1.4 [a-d[m-p]]-->指字符串中的某一个允许是a-d或m-p
1.5 [a-z&&[def]] -->指字符串中的某一个是a-z 并且 是def其中一个
1.6 [a-z&&[^bc]] -->指字符串中的某一个是a-z 但同时除了bc其中一个
1.7 [a-z&&[^m-p]] -->指字符串中的某一个是a-z,但同时除了m-p的其中一个
2 ) . 预定义字符类
2.1 . --> 任何字符(与行结束符可能匹配也可能不匹配)
2.2 \d -->  数字[0-9]
2.3 \D --> 非数字[^0-9]
2.4 \s --> 空白字符[\t\n\x0B\f\r]
2.5 \S --> 非空白字符[^\s]
2.6 \w --> 单词字符  [a-zA-Z_0-9]
2.7 \W --> 非单词字符  [^\w]
3 ) .  边界匹配器
3.1 ^  行的开头
3.2 $ 行的结尾
3.3 \b 单词边界
3.4 \B 非单词边界
3.5 \A 输入的开头
3.6 \G 上一个匹配的结尾
3.7 \Z 输入的结尾,仅用于最后的结束符
3.8 \z 输入的结尾
4 ) . Greedy数量词
4.1 X?     --> X, 一次也没有或一次
4.2 X*     --> X, 零次或多次
4.3X+     --> X, 一次或多次
4.4X
     --> X, 恰好n次
4.5 X[n,]     --> X, 至少n次
4.6 X[n,m]   --> X,至少n次,但不超过m次
5 ).  其它

5.1 {3}   --> 指限定某一位的次数为3

5.2 [2]  --> 指限定某一位的数值为2

5.3 ()  --> 指封装某一位的数 ,成为捕获组

5.4 () \1  --> 指选择第三个捕获组

[1] 解析:  ((A)(B(C)))   -->    第一个捕获组是 ((A)(B(C)))    ;  第二个捕获组是  (A)  ; 第三个捕获组是 (B(C)) ; 第四个捕获组是(C)   

[2] 如何数捕获组?   由左往右 数括号 
 
     三.  正则表达式(常见的功能 -匹配)
1 ) . Demo:
package cn.ittext.day01;/*** @author  winter* @Date    2018年4月2日上午9:58:29* @tel    1394869214@qq.com* @version 1.0* @describe 匹配*/public class RegexTelMatches02 {       public static void main(String[] args)       {             /**              *              * 庖丁解牛 : 正则表达式的常见操作              *              * 1.匹配 ->事实上就是使用 matches方法对规则与数值的比对匹配              *              * 2.切割              *              * 3.替换              *              * 4.获取              *              *              */              matches();        }              // 匹配       public static void matches()       {             //原始值             String tel ="181210ss57297";                          //完整版规则       //     String regex ="1[358][0-9]{9}";  //指第一位是1, 第二位 是 3||5||8 ,第三位 往后的 9个数 都是 0-9                          //升级版规则             String regex ="1[358]\\d{9}";  //\d指 数字0-9  , 多加一个\是为了转义                          //匹配             boolean matches = tel.matches(regex);                           //输出             sop(tel+"::::"+matches);                                 }       public static void sop(Object obj)       {             System.out.println(obj);       }}  
 
     四. 正则表达式(常见的功能 -切割)
1 ) . Demo:
package cn.ittext.day01;/*** @author  winter* @Date    2018年4月2日上午10:26:57* @tel    1394869214@qq.com* @version 1.0* @describe 切割*/public class RegexSplit03 {       public static void main(String[] args)       {             /**              *              * 庖丁解牛 : 正则表达式的常见操作              *              * 1.匹配 ->事实上就是使用 matches方法对规则与数值的比对匹配              *              * 2.切割  --> 事实上就是使用splits方法按规则对数值进行切割              *              * 3.替换              *              * 4.获取              *              *              */        //     splitText1();       //     splitText2();       //     splitText3();             splitText4();       }              //问题遗留       private static void splitText4()       {             //问题 : 当# 是偶数的时候则切割失败             String strs ="summer#######winter$$$$autumn";                          String regex ="(..)\\1+";                          String[] splits = strs.split(regex);                          for(String str : splits)             {                    sop(str);             }                                 }       //捕获组的方式切割       private static void splitText3()       {                          String strs ="summer######winter$$$$autumn";                          String regex ="(..)\\1+";   // .. 指任意的两个字符形成的第一组捕获组 , \\1+ 指第一组捕获组的一次或多次                          String[] splits = strs.split(regex);                          for(String str : splits)             {                    sop(str);             }                                 }       //普通切割       private static void splitText2()       {                          String strs ="summer           winter         autumn";                          String regex =" +";                                       String[] splits = strs.split(regex);                          for(String str : splits)             {                    sop(str);             }                                 }       // 切割       public static void splitText1()       {                          String strs ="summer winter autumn";                          String regex =" ";                          String[] splits = strs.split(regex);                          for(String str : splits)             {                    sop(str);                                 }                                 }       public static void sop(Object obj)       {             System.out.println(obj);       }}    

     五.  正则表达式(常见的功能 - 替换)
1 ) . Demo :
package cn.ittext.day01;/*** @author  winter* @Date    2018年4月2日上午11:02:17* @tel    1394869214@qq.com* @version 1.0* @describe 替换*/public class RegexReplaceAll04 {       public static void main(String[] args)       {             /**              *              * 庖丁解牛 : 正则表达式的常见操作              *              * 1.匹配 ->事实上就是使用 matches方法对规则与数值的比对匹配              *              * 2.切割  --> 事实上就是使用splits方法按规则对数值进行切割              *              * 3.替换  --> 事实上就是使用replaceAll方法按规则对数值进行替换              *              * 4.获取              *              *              */                    //     repleceText();             repleceText1();                    }                            //案例演示 : 手机号替换       private static void repleceText1()       {             /**              * 庖丁解牛 : 手机号码替换              *              * 原始: 18120057297              *              * 替换后: 181****2105              *              * 思路 :              *              * [1] 号码分3组 ,开头3位数为 1组 结尾4位数1组,中间 一组              *              * [2] 开头和结尾的两组正常显示 ,中间 一组替换为*即可              *              * 小结 : 当我们对某一组数字进行切割时,可通过分组的方式切,会更高效,更准确              *              */             //原始号码             String tel ="18120057297";                          //号码分组             String regex ="(\\d{3})(\\d{4})(\\d{4})";                          //将 分组1  和 分组3 正常显示,将分组2 替换为 * 即可             String replaceTel = tel.replaceAll(regex, "$1****$3");                          sop(replaceTel);                                 }       //替换演示       private static void repleceText()       {             String str ="zhangsan~~~~lisi&&&&wangwu";                          String regex ="(.)\\1+";                          String replaceAll = str.replaceAll(regex, "$1");  //将其中的~或&替换成一个字符                          /**              * $1  指的是 捕获 第一个捕获组中的数值              *              *              */             sop(replaceAll);       }       public static void sop(Object obj)       {             System.out.println(obj);       }}  
  
     六. 正则表达式( 常见的功能 -获取 )

1 ) . Demo :
package cn.ittext.day01;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** @author  winter* @Date    2018年4月2日上午11:37:19* @tel    1394869214@qq.com* @version 1.0* @describe 获取示例及 正则对象讲解*/public class RegexFind05 {       public static void main(String[] args)       {
             /**              *              * 庖丁解牛 : 正则表达式的常见操作              *              * 1.匹配 ->事实上就是使用 matches方法对规则与数值的比对匹配              *              * 2.切割  --> 事实上就是使用splits方法按规则对数值进行切割              *              * 3.替换  --> 事实上就是使用replaceAll方法按规则对数值进行替换              *              * 4.获取 --> 事实上就是使用 Pattern类的 mather方法  获取mather类 ,再通过 Mather类获取 find , group 等方法              *              *              */             
              regexFind();        }       private static void regexFind()       {                          /**              *              *              * 需求 : 在一大串字符串中获取 位数为3 的单词              *              * 思路:              *              * [1] 正则表达式 :  \\b\\w{3}\\b  \\b 指 单词边界 ,  \w指数字字符下划线任意字符连着的3位数              *              * [2] Pattern  : 正则表达式封装进正则对象              *              * [3] matcher : 正则对象获取匹配器              *              * [4] find  :匹配器中的 find 方法通过 正则表达式在 字符串中查找匹配              *              * [5] group : 匹配器中的 group方法获取 匹配成功的 字符串              *               * [6] start :  匹配器中的 start方法获取 匹配成功的 字符串 的开始坐标              *               * [7] end : 匹配器中的 end方法获取 匹配成功的 字符串 的结束坐标              *              *              * 小结 :              *              * [1] Pattern 是正则对象 , matcher是 匹配器 ,              *              * [2] 事实上 string中的相关正则方法底层应用的都是 pattern中的方法              *              */       String str ="ru guo ming tian de lu ,ni bu zhi dao wang na zou ,jiu liu xia lai";              String regex ="\\b\\w{3}\\b";                    //将正则表达式封装进对象       Pattern pat =Pattern.compile(regex);              //通过正则对象获取匹配器,与要匹配的字符串相关联       Matcher matcher = pat.matcher(str);              //通过匹配器对字符串进行相关操作              while(matcher.find()) //在字符串中查找正则固定的字符并返回 是否查找到 true 或flase       {        sop(matcher.group());//获取查找到的固定的字符并输出               sop(matcher.start()+"::"+matcher.end());  //获取匹配成功的字符串的起始和结束坐标       }                    }       public static void sop(Object obj) {             System.out.println(obj);       }}  
2 ) . 小结:  
2.1 Pattern是正则对象   -->用来封装正则表达式
2.2 matcher是正则对象中的匹配器   -->用来将原始值与正则表达式相关联 并 对 原始值进行相关操作  
小结 :  
           1.  作为于正则表达式的底层对象是 pattern类            

     七. 正则表达式(练习  -1 )
1 ) . Demo:
package cn.ittext.day01;/*** @author  winter* @Date    2018年4月2日下午1:30:33* @tel    1394869214@qq.com* @version 1.0* @describe 正则表达式练习一  : 去点去冗余*/public class RegexText1 {       public static void main(String[] args)       {             /**              * 庖丁解牛:              *              * 需求:治疗口吃              *              * 原始句: 我我我....我我我我....我喜喜欢....欢欢欢..你你你你你              *              * 最终句: 我喜欢你              *              * 思路: 通过替换的方式去点去冗余              *              *              */                                       text_1();                    }        private static void text_1()       {                          String str ="我我我....我我我我....我喜喜欢....欢欢欢..你你你你你";                          str = str.replaceAll("\\.+","");  //去点                          str = str.replaceAll("(.)\\1+","$1");  //去冗余                          sop(str);       }        public static void sop(Object obj)       {             System.out.println(obj);       }}  
  
     八.  正则表达式(练习  -2 )  -->IP排序
1 ) . Demo :
package cn.ittext.day01;import java.util.TreeSet;/*** @author  winter* @Date    2018年4月2日下午1:30:33* @tel    1394869214@qq.com* @version 1.0* @describe 正则表达式练习二   : 对IP地址排序*/public class RegexText2 {       public static void main(String[] args)       {             /**              * 庖丁解牛:              *              * 需求: 对IP地址排序              *              * 须知:  [1] IP地址是 每三位 一段 , 排序时按照每三位的数字进行排的              *              * 思路:               *              * [1] 先补零,让最少段数也都是 三位              *              * [2] 再抹位,去掉每段内多余三位数前边的零              *              * [3] 放入TreeSet自动排序              *              * [4] 再去掉冗余即可完成              *              *              */                                       text_2();                    }        private static void text_2()       {             String str_ip="192.168.1.2 174.32.1.2 183.23.43.2 1.0.20.2";  //原始值                          str_ip=str_ip.replaceAll("(\\d+)", "00$1");   //每段前都增加俩 0 ,按最多数增加 因此是俩                          str_ip=str_ip.replaceAll("0*(\\d{3})", "$1");  //再将每段超出3位数的 前边的 0 再抹掉                           String[] ips = str_ip.split(" +");  //以 空格为分割线切割                           TreeSet<String> ts =new TreeSet<String>();  // 将未排序的子串放入 自动排序的 TreeSet集合中                           for(String  ip : ips )               {                     ts.add(ip);    //放入集合              }                                        for(String ip : ts)  //从集合中打印出来              {                     sop(ip.replaceAll("0*(\\d+)", "$1"));  //去除多余的 0  ,前边是 原始值 ,后边是替换值                                  }               }        public static void sop(Object obj)       {             System.out.println(obj);       }}  
 小结 :  
           1.  使用替换方法replaceAll时,第一个参数传入的是 被替换的正则表示的形式 ,第二个参数 传入的是 替换后的 正则的表示形式                
     九.  正则表达式(练习 - 3)
1 ) . Demo:
package cn.ittext.day01;/*** @author  winter* @Date    2018年4月2日下午1:30:33* @tel    1394869214@qq.com* @version 1.0* @describe 正则表达式练习三   : 对邮件地址校验*/public class RegexText3 {       public static void main(String[] args)       {             /**              * 庖丁解牛:              *              * 需求: 对邮件地址校验              *              * 须知格式:  邮箱名@域名 . com(域名格式).cn(域名格式)              *              * [1] cn 可加可不加              *              * 思路:              *              * [1] 先确定固定格式              *              * [2] 在确定可变参数              *              * [3] 从而理清写正则表达式的思路              *              */                                       text_3();                    }        private static void text_3()       {             //原始值             String mail ="luojisiwei@luoluo.com.cn";                          //正则表达式             String regex="[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{2,3})+";                           /**              * 庖丁解牛: regex="[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{2,3})+"              *              *              * [1] [a-zA-Z0-9_]+@    指任意数字大小字符下划线位数不限,一直到@结束              *              * [2] [a-zA-Z0-9]+  指任意数字大小字符位数不限              *              * [3](\\.[a-zA-Z]{2,3})+  指 开头是 . ,后边 大小写字符2到3位, 然后()+包裹意思是循环              *              */             //进行匹配             boolean matches = mail.matches(regex);             //输出结果             sop(mail+":::"+matches);                                 }        public static void sop(Object obj)       {             System.out.println(obj);       }}  
 小结 :  
           1.  为某段可变参数书写正则表达式的规则方式 ,先确定固定格式,再确定可变参数,而后书写正则表达式              
     十. 正则表达式(练习 -4 爬虫)

1 ) . Demo:
package cn.ittext.day01;import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;import java.io.InputStreamReader;importjava.net.URL;import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** @author  winter* @Date    2018年4月2日下午2:53:03* @tel    1394869214@qq.com* @version 1.0* @describe  爬虫*/public class RegexText4 {       public static void main(String[] args) throws IOException       {                     List<String> qqs = getQQ();                           for(String qq : qqs)              {                     sop(qq);              }        }              public static List<String> getQQ() throws  IOException       {             //对本地文件进行爬取             //BufferedReader br =new BufferedReader(new FileReader("QQ.html"));                                       /**              *              * 概述: 网络爬虫其实就是一个程序用于在互联网中获取符合指定规则的数据              *              *              * 爬一个网页上的 QQ号              *              * 思路:              *              * [1] 读取网页内容              *              * [2] 自定义正则表达式              *              * [3] 获取网页内容每一行每一行的匹配 是否 符合 正则表达式的标准              *              * [4] 将符合标准的数据 放入 List集合中              *              *              * 步骤:              *              * [1] 读取源文件              *              * [2] 对读取的数据进行规则的匹配,从中获取符合规则的数据              *              * [3] 将符合规则的数据存储到集合中              *              */                          URL url =new URL("http://tieba.baidu.com/p/5613549346");  //自定义将要进行趴的网络地址                          BufferedReader br =new BufferedReader(new InputStreamReader(url.openStream())); //打开这个地址并获取其内容                          String regex ="> *\\d{8,11}";  //自定义匹配QQ的正则表达式                          String line =null;                           Pattern pt =Pattern.compile(regex);  //实例化正则对象并将正则表达式放入其中                          ArrayList<String> list =new ArrayList<String>();  //实例化数组用来存储 QQ数据                          while((line=br.readLine())!=null)  //按行读取网页内容             {                                        Matcher matcher = pt.matcher(line);  //正则对象调用 匹配器,匹配 网页行内容是否具有符合标准的数据                                         while(matcher.find())  //循环获取                     {                                               String group = matcher.group();  //将符合正则表达式的数据获取到                                               list.add(group);  //将符合正则表达式的数据放到List集合中                                         }                                 }             return list;  //返回集合        }       public static void sop(Object obj)       {             System.out.println(obj);       }}   
 
小结 :  
           1.  网络爬虫就是在互联网上找寻特定信息的程序         

     十一.  总结
1 ) . 正则使用总结:
[1] 正则表达式的规则需要什么查什么  ;   
[2] 正则表达式常用操作 :  匹配,切割, 替换,获取, 常用于过滤掉网络中的非法字符  --> 例如 : 某些论坛不可留 QQ号 
[3] IO流+ 网络编程 + 正则表达式  = 爬虫
须知  :  正则对象是 Pattern类 , 正则对象的匹配方法是mather()  ,  获取数据 必须用正则对象