Java基础:爬虫

🕗 发布于 2024-07-04 18:26 爬虫正则表达式 java

1.本地爬虫

Pattern:表示正则表达式

Matcher:文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。在大串中去找符合匹配规则的子串。

1.2.获取Pattern对象

通过Pattern p = Pattern.compile("正则表达式");获得

1.3.获取Matcher对象

通过Matcher m = p.matcher(str);获得 (m要在str中找符合p规则的小串)

其中, m为Matcher对象, p为正则表达式规则, str为要验证的字符串.

1.4.匹配文本中的对象

boolean b = m.find(); 表示拿着文本匹配器从头开始读取，寻找是否有满足规则的子串如果没有，方法返回false. 如果有，返回true。在底层记录子串的起始索引和结束索引+1.

1.5.截取文本匹配器的索引

String s = m.group(); 这时文本匹配器会停留在第一个匹配文本的结束索引+1处, 返回一个文本中索引为(0,4)不包含4索引的字符串(符合规则的).

1.6.继续匹配和获取索引

重复第4步和第五步, 从上一次停留的地方开始向后查找.

第4步和第5步一般通过while(m.find()){}循环实现.

package com.itheima.a08regexdemo;

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

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

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


        //1.获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //2.获取文本匹配器的对象
        //拿着m去读取str，找符合p规则的子串
        Matcher m = p.matcher(str);

        //3.利用循环获取
        while (m.find()) {
            String s = m.group();
            System.out.println(s);
        }


    }

    private static void method1(String str) {
        //Pattern:表示正则表达式
        //Matcher: 文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。
        //          在大串中去找符合匹配规则的子串。

        //获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //获取文本匹配器的对象
        //m:文本匹配器的对象
        //str:大串
        //p:规则
        //m要在str中找符合p规则的小串
        Matcher m = p.matcher(str);

        //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
        //如果没有，方法返回false
        //如果有，返回true。在底层记录子串的起始索引和结束索引+1
        // 0,4
        boolean b = m.find();

        //方法底层会根据find方法记录的索引进行字符串的截取
        // substring(起始索引，结束索引);包头不包尾
        // (0,4)但是不包含4索引
        // 会把截取的小串进行返回。
        String s1 = m.group();
        System.out.println(s1);


        //第二次在调用find的时候，会继续读取后面的内容
        //读取到第二个满足要求的子串，方法会继续返回true
        //并把第二个子串的起始索引和结束索引+1，进行记录
        b = m.find();

        //第二次调用group方法的时候，会根据find方法记录的索引再次截取子串
        String s2 = m.group();
        System.out.println(s2);
    }
}

爬取数据练习

package pacong;

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

/*
        需求:把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。
           来黑马程序员学习Java，
           手机号:18512516758，18512508907或者联系邮箱:boniu@itcast.cn，
           座机电话:01036517895，010-98951256邮箱:bozai@itcast.cn，
           热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090
        */
public class pacongdemo2 {
    public static void main(String[] args) {
//400-?[1-9]\\d{2}-?[1-9]\\d{3}
        /*
        分析:手机号: "1[3-9]\\d{9}"
        联系邮箱:"\\w+@[\\w&&[^_]]{2,6}(\\.)([a-zA-Z]{2,3}){1,2}"
        座机电话: "0\\d{2,3}-?[1-9]\\d{4,9};
        热线电话: "400-?[1-9]\\d{2}-?[1-9]\\d{3};
         */
        String s = "来黑马程序员学习Java，" +
                "电话:18512516758，18512508907" + "或者联系邮箱:boniu@itcast.cn，" +
                "座机电话:01036517895，010-98951256" + "邮箱:bozai@itcast.cn，" +
                "热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090";
        String regex="(1[3-9]\\d{9})" +
                "|(\\w+@[\\w&&[^_]]{2,6}(\\.)([a-zA-Z]{2,3}){1,2})" +
                "|(0\\d{2,3}-?[1-9]\\d{4,9})" +
                "|(400-?[1-9]\\d{2}-?[1-9]\\d{3})";
        //1.获取正则表达式的对象
        Pattern p = Pattern.compile(regex);
        //2.获取文本匹配器的对象
        Matcher m = p.matcher(s);
        //利用m去读取s,会按照p的规则去找大串s里面的小串
        //3.利用循环获取每一个数据 while(m.find())
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

结果

2.有条件的爬取数据

需求1:?相当于前面的java,起到占位符作用,后面的=表示在java后面跟随的数据,但是在获取的时候只获取前面部分.

需求2: 删除?= 表示java是8|11|17 或者是?: ----:?相当于前面的java,起到占位符作用,:就表示我们要拼8|11|17的数据

需求3:除了8|11|17的文本不要就输出?!即可

package pacong;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
//Pattern：表示正则表达式
Matcher：文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。
在大串中去找符合匹配规则的子串。
 */
public class pacongdemo4 {
    public static void main(String[] args) {
 /*
            需求1:爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。
            需求2:爬取版本号为8，11，17的Java文本。正确爬取结果为:Java8 Java11 Java17 Java17
            需求3:爬取除了版本号为8，11.17的Java文本，
        */
        String s = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        //1.定义正则表达式
        //?理解为前面的数据Java
        //=表示在Java后面要跟随的数据
        //但是在获取的时候，只获取前半部分
        //需求1:
        String regex1 = "((?i)Java)(?=8|11|17)";
        String regex2 = "((?i)Java)(8|11|17)";
        String regex3 = "((?i)Java)(?:8|11|17)";

        Pattern P=Pattern.compile(regex3);
        Matcher m=P.matcher(s);
       while (m.find()){
           System.out.println(m.group());
       }

    }
}

3.贪婪爬取和非贪婪爬取

贪婪爬取 : 在爬取数据的时候尽可能的多获取数据 (如:abbbbbbbbbbbb)

非贪婪爬取 : 在爬取数据的时候尽可能的少获取数据 (如:ab)

Java当中，默认的就是贪婪爬取

如果我们在数量词+或者*的后面加上问号，那么此时就是非贪婪爬取

贪婪爬取

public class pacongdemo3 {
    public static void main(String[] args) {
        String s = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
                "经历了很多版木，目前企业中用的最多的是]ava8和]ava11，因为这两个是长期支持版木。" +
                "下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String regex="ab+";
        Pattern P=Pattern.compile(regex);
        Matcher M=P.matcher(s);
        while (M.find()) {
            System.out.println(M.group());
        }
    }
}

结果:

非贪婪爬取

public class pacongdemo3 {
    public static void main(String[] args) {
        String s = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
                "经历了很多版木，目前企业中用的最多的是]ava8和]ava11，因为这两个是长期支持版木。" +
                "下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String regex="ab+?";
        Pattern P=Pattern.compile(regex);
        Matcher M=P.matcher(s);
        while (M.find()) {
            System.out.println(M.group());
        }
    }
}

结果:

4.正则表达式在字符串中的使用

先创建一个正则表达式规则, 然后传入字符串方法中, 返回的就是新的替换后的字符串或切割后的字符串数组了.

String类的split()方法原型：

public String[] split(String regex)
//参数regex表示正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。

replaceAll用法

public class pacongdemo5 {
    public static void main(String[] args) {
        /*
        有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
        要求1:把字符串中三个姓名之间的字母替换为vs
        要求2:把字符串中的三个姓名切割出来*/
        String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";

        //细节:
        //方法在底层跟之前一样也会创建文本解析器的对象
        //然后从头开始去读取字符串中的内容，只要有满足的，就用第二个参数去替换
        String regex="[\\w&&[^_]]+";
        String result = s.replaceAll(regex, "vs");
        System.out.println(result);
        
    }
}

结果:

split用法

package pacong;

public class pacongdemo5 {
    public static void main(String[] args) {
        /*
        有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
        要求1:把字符串中三个姓名之间的字母替换为vs
        要求2:把字符串中的三个姓名切割出来*/
        String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";

        //细节:
        //方法在底层跟之前一样也会创建文本解析器的对象
        //然后从头开始去读取字符串中的内容，只要有满足的，就用第二个参数去替换
        String regex="[\\w&&[^_]]+";
        /*String result = s.replaceAll(regex, "vs");
        System.out.println(result);*/
        //细节:
        //方法在底层跟之前一样也会创建文本解析器的对象
        //然后从头开始去读取字符串中的内容，只要有满足的，就用第二个参数去切割
        String[] str = s.split(regex);
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }


    }
}

结果:

5.分组

5.1.捕获分组

红色为第一组, 蓝色为第二组, 绿色为第三组

\\组号表示的就是把该组匹配的内容在匹配一遍, 两部分的内容相同.

package pacong;

public class pacongdemo6 {
    public static void main(String[] args) {
/*
 需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
举例: a123a b456b 17891 &abc& a123b(false)
\\组号:表示把第X组的内容再出来用一次
*/
        String regex1 = "(.).+\\1";
        //第一个.说的就是开头的字符是任意的,第2个点说的是中间的字符是任意的并且至少出现一次
        //  \\1表示我要把第一组的数据a再用一次
        System.out.println("a123a".matches(regex1));
        System.out.println("b456b".matches(regex1));
        System.out.println("17891".matches(regex1));
        System.out.println("&abc&".matches(regex1));
        System.out.println("a123b".matches(regex1));
        System.out.println("--------------------------");
        //需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符
        //举例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)
        String regex2 = "(.+).+\\1";
        System.out.println("abc123abc".matches(regex2));
        System.out.println("b456b".matches(regex2));
        System.out.println("123789123".matches(regex2));
        System.out.println("&!@abc&!@".matches(regex2));
        System.out.println("abc123abd".matches(regex2));
        System.out.println("---------------------");
        //需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致
        //举例: aaa123aaa bbb456bbb 111789111 &&abc&&
        //(.):把首字母看做一组
        // \\2:把首字母拿出来再次使用
        // *:作用于\\2,表示后面重复的内容出现0次或多次
        String regex3 = "((.)\\2*).+\\1";
        System.out.println("aaa123aaa".matches(regex3));
        System.out.println("bbb456bbb".matches(regex3));
        System.out.println("111789111".matches(regex3));
        System.out.println("&&abc&&".matches(regex3));
        System.out.println("aaa12aab".matches(regex3));
        System.out.println("---------------------");
    }
}

String regex3 = "((.)\\2*).+\\1";

分析:

首先开头的是任意字母(.) ,接着是重复上一个的字母我们写\\1,\\表示把第X组的内容再出来用一次,这里是第一组,然后写一个*,这个*表示重复0次或者多次, 接着出现了.+,这个.+表示中间的字符,.表示任意字符,+表示至少出现一次, 然后最后一段的字符和开头的字符重复,所以我们把第一组括起来,然后根据分组规则,已括号为基准,所以里面的为第二组,所以改为\\2

(.)代表的是a字符 ,接着\\1重复上一个字符a的内容,然后*代表的是a字符至少出现0次,在写中间的字符(123),写一个(.+)就即可,然后写末端的aaa,怎么写呢,其实就是把前面的整体拿着用重复一次罢了,于是我们就要用括号括起来,就要把\\1改成\\2,后面写\\1

结果:


public class pacongdemo7 {
    public static void main(String[] args) {
//需求:把重复的内容 替换为 单个的
//学学                学
//编编编编            编
//程程程程程程        程
//  (.)表示把重复内容的第一个字符看做一组
//  \\1表示第一字符再次出现
//  + 至少一次
//  $1 表示把正则表达式中第一组的内容，再拿出来用
        String str = "我要学学编编编编程程程程程程";
        String regex="(.)\\1+";
        System.out.println(str.replaceAll(regex,"$1"));

    }
}

结果:

5.2非捕获分组

特点:不占用组号

总结

原文地址：https://blog.csdn.net/weixin_65752158/article/details/140161481

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：数据库开发：mysql基础一
下一篇：YOLOv8模型调参---数据增强

python：编写一个函数查找字符串中的最长公共前缀
使用列表中的第1个元素作为比较对象，依次对比第1个元素中的每1位字符是否与其他元素的该位置的字符一致，如果一致就加入到新的列表，遇到不一致的就break退出，最后通过字符串的join方法返回公共前缀。
阅读更多2024-09-23
机器人速度雅可比矩阵求解(2自由度平面关节机器人)
矩阵求逆博图SCL_博图矩阵运算-CSDN博客文章浏览阅读839次。本文介绍如何用C语言实现矩阵求逆的过程，详细解析了相关代码，适合线性代数和编程爱好者学习。
阅读更多2024-09-23
pg入门11—pg中的foregin data wrappers是什么
在 PostgreSQL（PG）中，是一种允许 PostgreSQL 从外部数据源（如其他数据库、文件系统、NoSQL 数据库等）读取和写入数据的机制。通过 FDW，PostgreSQL 可以像访问本
阅读更多2024-09-23
Redis: 学习参考资料
一、Redis数据结构应用场景https://www.bilibili.com/video/BV1464bepEjY?p=3&vd_source=cd03889ff27e1a185b3
阅读更多2024-09-23
Android 命令行关机
这个命令会立即关闭设备。如果你需要更复杂的关机流程或自定义行为，也可以通过修改系统服务实现。
阅读更多2024-09-23
Java | Leetcode Java题解之第421题数组中的两个数的最大异或值
Java | Leetcode Java题解之第421题数组中的两个数的最大异或值
阅读更多2024-09-23
autodl连接xftp
autodl进行连接本地xftp
阅读更多2024-09-23
vue scoped解析
从上面的图可以看出，给style加上scoped之后，会给这个模块的所有元素都加上一个自定义属性data-v-xxxx，这个xxxx就是这个文件的相对路径加上文件名生成的hash值，这样就能保证自定义
阅读更多2024-09-23
HTML5中新增元素介绍
引入了许多新元素，以增强网页的语义和功能。这些新元素大致可以按以下几类进行分类和介绍。下面是对各标签的详解，section、header、footer、nav、article、aside、figure
阅读更多2024-09-23
go语言网络编程
TOCTOC。
阅读更多2024-09-23