Java—— 爬虫

所涉及到的类：

Pattern：表示正则表达式

Matcher：表示文本匹配器，其作用是按照正则表达式的规则从头开始去读字符串，在大串中寻找符合匹配规则的小串

具体实现格式：

获取需要进行查找的大串

String str = " 需要进行查找的大串 " ；

获取正则表达式的对象

Pattern p = Pattern.compile(" 正则表达式具体规则 ")； 

获取文本匹配器的对象

代表m要在str大串中找符合p规则的小串

Matcher m = p.matcher(str)；

调用find()方法，让文本匹配器从头开始读取大串，寻找是否有满足规则的子串
如果没有，方法返回false
如果有，返回true。在底层记录子串的起始索引和结束索引+1

boolean flag = m.find()；

调用group()方法截取子串

方法底层会根据find()方法记录的索引进行字符串的截取

方法底层调用substring(起始索引，结束索引)；包头不包尾
返回截取的小串，该小串就是符合正则表达式要求的子串
String s1 = m.group();
System.out.println(s1);

想要继续向后查找，可以重复调用find()方法和group()方法，或直接利用循环进行查找

案例演示：

需求：

有如下文本，请按照要求爬取数据。
"Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11,
因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台"
要求:找出里面所有的JavaXX

代码实现：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test8 {
    public static void main(String[] args) {

        //获取需要进行查找的大串
        String str = "Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11," +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        //获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");

        //获取文本匹配器的对象
        Matcher m = p.matcher(str);

        //调用find()方法，让文本匹配器从头开始读取大串，寻找是否有满足规则的子串
        //找到了返回true进入循环进行截取，找不到返回false结束循环
        while(m.find()){
            //调用group()方法截取子串
            String s = m.group();
            System.out.println(s);
        }
        //Java
        //Java8
        //Java11
        //Java17
        //Java17
    }
}

带条件爬取：

需求：

需求1:爬取版本号为8,11,17的Java文本，但是只要Java，不显示版本号。
需求2:爬取版本号为8,11,17的Java文本。正确爬取结果为:Java8 Java11 Java17 Java17
需求3:爬取除了版本号为8,11,17的Java文本

分析及代码：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test9 {
    public static void main(String[] args) {

        String str = "Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11," +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        //需求1
        //其中 ?是占位符代表字符串Java，=表示字符串Java后面连接的部分
        //但是在获取的时候，只获取=前半部分
        String regex1 = "Java(?=8|11|17)";
        //调用方法进行爬虫
        show(regex1,str);
        //Java
        //Java
        //Java
        //Java


        //需求2
        //方式1：常规方式
        String regex2 = "Java(8|11|17)";
        show(regex2,str);
        //Java8
        //Java11
        //Java17
        //Java17

        //方式2：?是占位符代表字符串Java，:表示字符串Java后面连接的部分
        //在获取的时候，可以全部获取
        String reges3 = "Java(?:8|11|17)";
        show(reges3,str);
        //Java8
        //Java11
        //Java17
        //Java17

        //需求3
        //?是占位符代表字符串Java，!表示字符串Java后面连接的部分
        ///在获取的时候，获取的是除了与!后面连接匹配的子串
        String regex4 = "Java(?!8|11|17)";
        show(regex4,str);//Java
    }

    //抽取一个方法进行爬虫
    public static void show(String regex,String str){
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);
        while(m.find()){
            String s = m.group();
            System.out.println(s);
        }
    }
}

贪婪爬取与非贪婪爬取：

说明： 

贪婪爬取:在爬取数据的时候尽可能的多获取数据
非贪婪爬取:在爬取数据的时候尽可能的少获取数据

格式： 

只写+和*表示贪婪匹配
+?表示非贪婪匹配    *? 表示非贪婪匹配

例如：

需要查找的字符串为：abbbbbbbbbbbb

ab+  贪婪爬取：abbbbbbbbbbbb
ab+? 非贪婪爬取：ab

注意事项： 

Java当中，默认的就是贪婪爬取
如果我们在数量词+*的后面加上问号，那么此时就是非贪婪爬去

代码演示：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test10 {
    public static void main(String[] args) {

        String str = "1234567abbbbbb87abbb6545678";

        //贪婪爬取
        String regex1 = "ab+";
        show(regex1,str);
        //abbbbbb
        //abbb

        //非贪婪爬取
        String regex2 = "ab+?";
        show(regex2,str);
        //ab
        //ab
    }

    public static void show(String regex,String str){
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);
        while(m.find()){
            String s = m.group();
            System.out.println(s);
        }
    }
}