正则表达式和爬虫

- 日理万妓 2022-04-23 22:00 266阅读 0赞

### 正则表达式 ###

*  简介
    
    正则表达式是由一些具有特殊含义的字符组成的字符串，用于查找，替换符合规则的字符串在表达单验证，Url映射等处都会经常用到。
 *  概述
    
    (1)正则表达式：符合一定规则的表达式
    
    作用：用于专门操作字符串
    
    特点：用于一些特点的符号来表达一些代码操作，这样就简化书写，就是学特殊符号的使用。
    
    好处：可以简化对字符串的复杂的操作。
    
    弊端：符号定义越多，正则越长，阅读性越差。
 *  常见的功能
    
    （2）具体操作的功能：
    
    **匹配**：String mstches方法，用来规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false，也就是说返回值为boolean类型。
    
    切割：String split();使用String类中的split方法进行对字符串的分割，其中split方法具有按照一定规则分割的字符串的功能。
    
    替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式的已有的组。
    
    获取：将字符串中符合的规则的子串取出，操作步骤：
    
    1.将正则表达式封装成对象
    
    2.让正则对象和要操作的字符串相关关联。
    
    3.关联后，获取正则匹配引攀。
    
    4.通过引攀对符合规则的子串进行操作，比如取出。
    
    （3）使用的思路:
    
    1.如果只想知道该字符是否是对错，使用匹配。
    
    2.如果将已有的字符串变成另一个字符串，使用替换。
    
    3.想要按照自定的方式将字符串变成多个字符串，使用切割，获取规则以外的字符串。
    
    4.想要拿到符合需求的字符串子串，获取，获取符合规则的子串。
 *  String类中的方法
    
    Matcher 类：
    
    Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
    
    boolean:`matches(String regex)` 告知此字符串是否匹配给定的\[正则表达 式\]
 *  类Pattern
    
    pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
    
    代码演示：
    
        package com.luliang.day01;
        import java.util.Scanner;
        import java.util.regex.Pattern;
        //类 Pattern 中的static boolean方法中的matches(String regex,CharSequence input)编译给
        //定正则表达并尝试给定输入与其匹配.
        public class Demo01 {
            public static void main(String[] args) {
                String reg = "1[3,5,8][0-9]{12}";
                Scanner sc = new Scanner(System.in);
                String str = sc.nextLine();
                boolean matches = Pattern.matches(reg,str);
                System.out.println(matches);
            }
        }
    
    练习：
    
    代码演示第一种：
    
        package com.luliang.day01;
        
        import java.util.Scanner;
        
        public class Demo02 {
            public static void main(String[] args) {
                lu();
            }
            //定义一个方法Lu
            public static void lu(){
                System.out.println("请你输入qq号:");
                Scanner scanner = new Scanner(System.in);
                String qq = scanner.nextLine();
                String regex="[1-9]\\d{4,14}";//通过正则表达式进行匹配
                boolean matches = qq.matches(regex);//进行判断
                if(matches){
                    System.out.println("你输入qq"+qq+":符合规则.");
                }else {
                    System.out.println("你输入qq"+qq+":不符合规则.");
                }
            }
        }
        //String regex="[1-9]\\d{4,14}";表示匹配规则式这个字符串中的第一位是1-9的数字,后面\\d表示后面全是数字,
        //{4,14}表示此时首位已经确定,这个字符串的余下的长度为4-14,如果匹配成功,则合法输出,不成功输出不合法
        //当然首字母和其他不能出现其他字符.
    
    代码演示第二种：
    
        package com.luliang.day01;
        
        import java.util.Scanner;
        
        public class Demo03 {
            public static void main(String[] args) {
             lu();
            }
        
            public static void lu() {
                System.out.println("请你输入qq号:");
                Scanner scanner = new Scanner(System.in);
                String qq = scanner.nextLine();
                String regex = "[1-9]\\d{4,14}";//通过正则表达式进行匹配
                if(qq.length()>=5&&qq.length()<=14){
                    if(!qq.startsWith("0")){
                        try {
                            long l = Long.parseLong(qq);
                            System.out.println(l+"符合规则");
                        }catch (Exception e){
                            System.out.println(qq+":含有非法字符.");
                        }
                    }else {
                        System.out.println(qq+":0不能开头");
                    }
                }else {
                    System.out.println(qq+":长度不合法");
                }
            }
        }
        
 *  常见的功能
    
    1.匹配:
    
    题目:需求匹配手机号码段只有13xxx 15xxx 18xxx
    
    代码如下:
    
        package com.luliang.day01;
        
        import java.util.Scanner;
        //匹配
        public class Demo04 {
            public static void main(String[] args) {
            lu();
            }
        
            //创建一个方法
            public static void lu() {
                System.out.println("请输入电话号码:");
                Scanner scanner = new Scanner(System.in);
                String dianhua = scanner.nextLine();
                String telReg = "1[358]\\d{9}";
                if(dianhua.charAt(1)==3&&dianhua.charAt(1)==5&&dianhua.charAt(1)==8) {
                    if (dianhua.length() == 9) {
                        if (!dianhua.startsWith("[0,9]")) {
                            try {
                                long l = Long.parseLong(dianhua);
                                System.out.println(l + "符合规则.");
                            } catch (Exception e) {
                                System.out.println(dianhua + "含有非法字符.");
                            }
                        } else {
                            System.out.println(dianhua + "不能以数字0-9数字为开头.");
                        }
                    } else {
                        System.out.println(dianhua + "输入的电话号码不能大于小于9为位.");
                    }
                }else {
                    System.out.println(dianhua+"输入的号码第二位不能不是3,5,8");
                }
            }
        }
        //1代表开头以1为开头,[3.5,8]代表第二个只能为3,5,8,\\d代表之后都是数字{9}代表电话号码只能为9位.
        
    
    练习2.需求对邮件地址进行效验.
    
     
    
        package com.luliang.day01;
        
        import java.util.Scanner;
        
        public class Demo05 {
            public static void main(String[] args) {
             lu();
            }
            public static void lu(){
                System.out.println("请你输入邮箱:");
                Scanner scanner = new Scanner(System.in);
                String s = scanner.nextLine();
                String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
                System.out.println("邮箱的地址匹配为:"+s.matches(reg));
            }
        }
    
    切割:String split();
    
    练习1.有时候,当我们获取用户文本的时候,会有很多无意义的空格,当我们只想获取关键字,那我们可以进行以下操作.文本转化为有意义的单个关键字.

package com.sample;
    class  RegexDemo
    {
        public static void main(String[] args)  {
            String reg = " +";//按照多个空格来进行切割，reg的内容为：空格和+：表示使用一个空格或多个空格分割
            String str="我           是          ，哈         哈，  ，                      你好   吗？？";
            splitDemo(str, reg);
        }
        public static void splitDemo(String str,String reg)
       {
            String[] arr = str.split(reg);   
            System.out.println(arr.length);
            for(String s : arr)
            {
                System.out.println(s);
            }
        }
    }

练习2.按照将字符串分割,如下代码

package com.luliang.day01;
    
    public class Demo08 {
        public static void main(String[] args) {
            lu("zhangsanknsjkankannnnnnnn.sadad.asdasd","\\.");
        }
        public static void lu(String str,String reg){
            String[] arr=str.split(reg);
            System.out.println(arr.length);//计算长度
            for (String s : arr) {
                System.out.println(s);
            }
        }
    }

练习3.我们使用\\\\\\,进行对路径进行匹配,代码如下.

package com.luliang.day01;
    //我们使用\\\,进行对路径进行匹配
    public class Demo09 {
        public static void main(String[] args) {
            lu("C:\\Users\\ASUS\\Desktop\\截图\\222.jpg","\\\\");
        }
        public static void lu(String str,String arg){
            String[] arr=str.split(arg);
            System.out.println(arr.length);
            for (String s : arr) {
                System.out.println(s);
            }
        }
    }

练习4:进行分割叠词

package com.luliang.day01;
    //进行分割叠词
    public class Demo10 {
    
        public static void main(String[] args) {
                 lu("erkktyqqquizzzffdssddasfdsfdddfvcxvffdvfvzzo","(.)\\1+");
        }
        public static void lu(String str,String reg) {
            String[] arr = str.split(reg);
            System.out.println(arr.length);
            for (String s : arr) {
                System.out.println(s);
            }
        }
    }

为了可以让规则的结果被重用，可以将规则封装成一个组。用()完成。组的出现都有编号，从1开始。 想要使用已有的组可以通过 \\n(n就是组的编号)的形式来获取。下面是结果：即以叠词作为分隔符

捕获:

练习1:给定过一个字符串来找到数字串

package com.luliang.day01;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class Demo11 {
        public static void main(String[] args) {
            // 按指定模式在字符串查找
            String line = "This order was placed for QT3000! OK?";
            String pattern = "(\\D*)(\\d+)(.*)";
    
            // 创建 Pattern 对象
            Pattern r = Pattern.compile(pattern);
    
            // 现在创建 matcher 对象
            Matcher m = r.matcher(line);
            if (m.find( )) {
                System.out.println("Found value: " + m.group(0) );
                System.out.println("Found value: " + m.group(1) );
                System.out.println("Found value: " + m.group(2) );
                System.out.println("Found value: " + m.group(3) );
            } else {
                System.out.println("NO MATCH");
            }
        }
    }

*  练习
 *  练习爬虫
    
    本地爬虫
    
        package com.luliang.day02;
        
        import java.io.BufferedReader;
        import java.io.FileReader;
        import java.util.ArrayList;
        import java.util.regex.Matcher;
        import java.util.regex.Pattern;
        
        public class Demo01 {
            public static void main(String[] args) throws Exception{
                ArrayList<String> mails = getMails();
                for (String mail : mails) {
                    System.out.println(mail);
                }
            }
            //本地爬
            public static ArrayList<String>  getMails()throws Exception{
                //1.读取源文件
                BufferedReader bufferedReader = new BufferedReader(new FileReader("a.txt"));
                //2.对读取的数据进行规则的匹配,选中符合规则的数据
                String regex="[\\w&&[^_]]\\w+@\\w+(\\.\\w+)+";
                ArrayList<String> strings = new ArrayList<>();
                Pattern compile = Pattern.compile(regex);
                String line=null;
                while ((line=bufferedReader.readLine())!=null){
                    Matcher matcher = compile.matcher(line);
                    //将符合规则的数据存储到集合中
                    while (matcher.find()){
                        strings.add(matcher.group());
                    }
                }
                return strings;
            }
        }
        
    
    爬虫一般分三步:
    
    1.建立网络连接,爬取数据
    
    2.建立正则表达式
    
    3.使用正则表达式爬取获得的数据
    
    如果数量比较大,可以选择线程池,连接池并发.
    
    练习爬取一个小说网站到本地:
    
    项目要求:
    
    JVAVA爬虫 并发 爬取静态小说网站的全部小说
    
    用到知识点:
    
        1. HttpClient请求
        2. 连接池并发
        3. 线程池并发
        4. 正则表达式
        5. IO流保存本地文件
    
    第一步:**HttpClient请求**
    
    注意事项:
    
    1.连接的选择:不使用`HttpURLConnection`
    
    > HttpClient就是一个增强版的HttpURLConnection，
    > 
    > HttpURLConnection可以做的事情HttpClient全部可以做；
    > 
    > HttpURLConnection没有提供的有些功能，
    > 
    > HttpClient也提供了， 但它只是关注于如何发送请求、接收响应，以及管理HTTP连接。
    
    2.实体类的读取
    
    >     强烈不推荐使用 EntityUtils 类，  
    >     除非响应实体来源于可信的 HTTP 服务器，并且知道它的最大长度。
    >     所以这一步我用的是字符缓冲流
    
    爬取网页:
    
        package com.luliang.day02;
        
        import java.io.BufferedReader;
        import java.io.IOException;
        import java.io.InputStreamReader;
        import java.net.MalformedURLException;
        import java.net.URL;
        import java.nio.charset.Charset;
        import java.util.ArrayList;
        import java.util.regex.Matcher;
        import java.util.regex.Pattern;
        
        public class Demo02 {
            public static String getURLContent(String urlStr, String charset){
                StringBuffer res = new StringBuffer();
                try {
                    URL url = new URL(urlStr);
        
                    BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream(), Charset.forName(charset)));
                    String str = null;
        
                    while ((str = br.readLine()) != null) {
                        res.append(str);
                    }
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        
                return res.toString();
            }
        
            public static ArrayList<String> getMatherSubstrs(String destStr, String regexStr){
                Pattern pattern = Pattern.compile(regexStr);
                Matcher mather = pattern.matcher(destStr);
                ArrayList<String> res = new ArrayList<String>();
                while(mather.find()){
                    //System.out.println(mather.group());
                    //System.out.println(mather.group(1));
                    res.add(mather.group(1));
                }
        
                return res;
            }
        
            public static void main(String[] args) {
                String destStr = getURLContent("https://www.qidian.com", "gbk");
                //System.out.println(destStr);
        
                ArrayList<String> list = getMatherSubstrs(destStr, "href=\"(.+?)\"");
        
                for (String temp : list) {
                    System.out.println(temp);
                }
        
            }
        }
        
    
     
 *  常见的正则表达式
 *  常见的规则
    
        字符类
        [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
         空白字符：[ \t\n\x0B\f\r]
        \S
         非空白字符：[^\s]
        \w
         单词字符：[a-zA-Z_0-9]
        \W
         非单词字符：[^\w]
        
        边界匹配器
        ^
         行的开头
        $
         行的结尾 
        \b
         单词边界 
        \B
         非单词边界
        \A
         输入的开头
        \G
         上一个匹配的结尾
        \Z
         输入的结尾，仅用于最后的结束符（如果有的话）
        \z
         输入的结尾
        
        Greedy 数量词
        X?
         X，一次或一次也没有 
        X*
         X，零次或多次 
        X+
         X，一次或多次
        X{n}
        X{n,}
         X，至少 n 次
        X{n,m}
         X，至少 n 次，但是不超过 m 次
        
        . 代表一个元字符
        
        v    a.b  匹配“avb” ,“a b” ，但不匹配a00b
        
        ^ 在字符串里代表开始，在[]里代表取反。
        
        v    ^j.*va 匹配”j123skdva”, a[^0-9]b匹配”arb”，不能匹配”a1b”
        
        $ 行的结尾
        
        v    a.c0$ 匹配”abc0”
        
        | 或者
        
        v    a+|b+ 匹配“aa”, “a”, “bbb”, “b”
        
        []
        
        v    正则表达式r[aou]t匹配rat、rot和rut，但是不匹配ret 
        
        -
        
        v    [A-Za-z]可以匹配任何大小写字母
        
        * 出现零次或者多次
        
        v    a.*b 匹配”abbb”, “a67b”
        
        + 最少出现一次
        
        v    a+ 匹配“aa”, “a”
        
        ? 重复零次或一次 
        
        v    a.*b:?0$ 匹配“aab:0” “aab0”
        
        {}
        
        v    正则表达式A[0-9]{3} 能够匹配字符"A"后面跟着正好3个数字字符的串，例如A123、A348等 
        
        v    正则表达式[0-9]{4,6} 匹配连续的任意4个、5个或者6个数字字符
        
        v    正则表达式[0-9]{4,}匹配连续的任意4个或以上数字字符
         
        
        ^ 行的开头      
        
        $ 行的结尾 
        
        \b 单词边界 
        
        \B 非单词边界 
        
        \A 输入的开头 
        
        \G 上一个匹配的结尾 
        
        \Z 输入的结尾，仅用于最后的结束符（如果有的话） 
        
        \z 输入的结尾 
        
        \d 数字：[0-9] 
        
        \D 非数字： [^0-9] 
        
        \s 空白字符：[ \t\n\x0B\f\r] 
        
        \S 非空白字符：[^\s] 
        
        \w 单词字符：[a-zA-Z_0-9] 
        
        \W 非单词字符：[^\w]