Java的正则表达式和爬虫

🕗 发布于 2024-11-22 00:55 java 正则表达式爬虫

正则表达式`Regex`和爬虫

正则表达式（Regular Expression，简称 Regex）是一种文本匹配的模式，用于对字符串进行搜索、匹配、提取、替换等操作。它广泛应用于字符串处理领域，例如文本解析、验证用户输入、文件内容查找等。

作用：

校验字符串是否满足规则
在一段文本中查找满足要求的内容

一、正则表达式语法：

在这里插入图片描述

正则表达式在字符串方法中的使用：

方法名	说明
public boolean matches(String regex)	判断字符串是否满足正则表达式的规则
public String replaceAll(String regex,String newStr)	按照正则表达式的规则进行替换
public String[] split(String regex)	按照正则表达式的规则切割字符串

方法2、3的演示：

public class RegexDemo07 {
    public static void main(String[] args) {
        // 正则表达式在字符串方法中的使用

        // 有一段字符串：小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
        // 要求1：把字符串中三个姓名之间的字母替换为vs
        // 要求2：把字符串中的三个姓名切割出来

        String str = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
        String str1 = str.replaceAll("[\\w&&[^_]]+", "VS");
        System.out.println(str1);// 输出： 小诗诗VS小丹丹VS小惠惠
        // 细节：
        // 方法在底层跟之前一样也会创建文本解析器的对象
        // 然后从头开始去读取字符串中的内容，只要有满足的，那么就用第二个参数去替换

        // 在所指定的文本处分割
        String[] strarr = str.split("[\\w&&[^_]]+");
        for (int i = 0; i < strarr.length; i++) {
            System.out.println(strarr[i]);// 输出： 小诗诗 小丹丹 小惠惠
        }
    }
}

详细示例：

public class RegexDemo01 {
    public static void main(String[] args) {
        // 验证手机号码： 13815644862 19748524761
        String regex1 = "1[3-9]\\d{9}";
        // 验证分成三部分：
        // 第一部分： 1 表示手机号码只能以1开头
        // 第二部分： [3-9] 表示手机号码第二位只能是3-9之间的
        // 第三部分： \\d{9} 表示任意数字可以出现9次，也只能出现9次
        System.out.println("13546874556".matches(regex1));  // 输出： true
        System.out.println("12546874556".matches(regex1));  // 输出： false
        System.out.println("62546874556".matches(regex1));  // 输出： false
        System.out.println("125468745565".matches(regex1)); // 输出： false

        // 验证座机号码： 020-2324242 02122442 027-42424 0712-3242434
        String regex2 = "0\\d{2,3}-?\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));  // 输出： true
        System.out.println("02122442".matches(regex2));     // 输出： true
        System.out.println("0712-3242434".matches(regex2)); // 输出： true
        System.out.println("07123-3242434".matches(regex2));// 输出： false

        // 验证邮箱号码：
        // 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        // 细节：
        // 要显示.需要加转义字符——因为.是预定义字符，代表任何字符 \\.
        // .com这类的可以出现一次或两次，这时候可以使用()进行分组，可以在后面规定出现的次数

        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("3232323@qq.com".matches(regex3));       // 输出： true
        System.out.println("zhangsan@itcast.cnn".matches(regex3));  // 输出： true
        System.out.println("dlei0009@163.com".matches(regex3));     // 输出： true
        System.out.println("dlei0009@pci.com.cn".matches(regex3));  // 输出： true
        // 在实际的开发中，很少会自己写正则表达式
        // 百度一个类似的，自己改成公司要求的

        // 24小时的正则表达式
        String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
        System.out.println("23:11:11".matches(regex4)); // 输出： true

        // 身份证号码的简单校验
        String regex5 = "[1-9]\\d{16}(\\d|X|x)";
        // String regex5 = "[1-9]\\d{16}(\\d|[Xx])";
        // String regex5 = "[1-9]\\d{16}(\\d|(?i)x)";
        System.out.println("41080119930228457x".matches(regex5));   // 输出： true
        System.out.println("510801197609022309".matches(regex5));   // 输出： true
        System.out.println("15040119810705387X".matches(regex5));   // 输出： true
        System.out.println("130133197204039024".matches(regex5));   // 输出： true
        System.out.println("430102197606046442".matches(regex5));   // 输出： true

        // 忽略大小写的书写方式
        // 在匹配的时候忽略abc大小写
        String regex6 = "(?i)abc";
        // 忽略(?i)后面的大小写
        System.out.println("------------------------");
        System.out.println("abc".matches(regex6));  // 输出： true
        System.out.println("Abc".matches(regex6));  // 输出： true
        System.out.println("ABC".matches(regex6));  // 输出： true
        // 如果要仅忽略b的大小写
        String regex7 = "a((?i)b)c";
        System.out.println("------------------------");
        System.out.println("abc".matches(regex7));  // 输出： true
        System.out.println("ABc".matches(regex7));  // 输出： false
        System.out.println("aBc".matches(regex7));  // 输出： true

        // 身份证号码的复杂校验
        //前面6位：省份，市区，派出所等信息 第一位不能是0，后面5位是任意数字
        //年的前半段：18 19 20
        //年的后半段：任意数字出现两次
        //月份：01~09 10 11 12
        //日期：01~31
        //后面四位：任意数字出现3次 最后一位可以是数字也可以是大写x或者小写x
        String regex8 = "[1-9]\\d{5}(18|19|20)\\d{2}(0\\d|1[0-2])([0-2]\\d|3[01])\\d{3}(\\d|(?i)x)";
        System.out.println("41080119930228457x".matches(regex8));
        System.out.println("510801197609022309".matches(regex8));
        System.out.println("15040119810705387X".matches(regex8));
        System.out.println("130133197204039024".matches(regex8));
        System.out.println("430102197606046442".matches(regex8));
    }
}

在这里插入图片描述

二、爬虫：

本地爬虫
网络爬虫

原理：通过正则表达式从文本中爬取指定的数据。

1、本地爬虫

从一个字符串中爬取指定的数据

需要用到regex包下的两个类Pattern和Matcher

Pattern——表示正则表达式
Matcher——文本匹配器，按照正则表达式的规则去读取字符串，从头开始读取

示例：

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

        // 获取正则表达式对象
        // 调用Pattern中的静态方法来创建Pattern对象————Pattern.compile()
        Pattern p = Pattern.compile("Java\\d{0,2}");

        // 获取文本匹配器对象
        // 调用Pattern中的matcher方法传递所要查询的源文本，返回的类型就是Matcher
        Matcher m = p.matcher(str);
        // m: 文本匹配器对象
        // str: 所要查询的源文本
        // p: 规则
        // 即： m要在str中找到符合p规则的小串

        // 拿着文本匹配器从开头开始读取，寻找是否有满足规则的子串
        // 如果没有，方法就返回false
        // 如果有，则返回true，并在底层记录子串的起始索引和结束索引+1

        // boolean b = m.find();
        // 方法底层会根据find方法记录的索引进行字符串的截取
        // subString(起始索引， 结束索引)；包头不包尾
        while(m.find()) {
            String s = m.group();
            System.out.println(s);
        }

注意事项：

文本匹配器每调用一次find()方法，它捕获到的指定格式文本也会搜索下一个
且find()方法的返回值为布尔类型，也可用于判断是否有想要获取的文本
当调用Matcher中的group()方法时，底层会返回截取到的子字符串

2、网络爬虫

从网站中爬取想要的数据

这里准备了一个带随机生成身份证号的网站：https://yapi.pro/mock/583732/getsource

示例代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo03 {
    public static void main(String[] args) throws IOException {
        // 网络爬虫
        // 从网站中爬取想要的数据

        // 创建一个URL对象
        URL url;
        try {
            url = new URL("https://yapi.pro/mock/583732/getsource");
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }

        // 连接上这个网站————保证网络是畅通的
        URLConnection conn = url.openConnection();

        // 创建一个对象去读取网站中的数据
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;

        // 获取正则表达式的对象 Pattern
        String regex = "[1-9]\\d{17}";
        Pattern pattern = Pattern.compile(regex);
        // 在读取的时候每次读一整行
        while((line = br.readLine()) != null) {
            // 拿着文本匹配器的对象matcher按照pattern的规则去读取当前的这一行信息
            Matcher matcher = pattern.matcher(line);
            while(matcher.find()) {
                System.out.println(matcher.group());
            }
        }

        br.close();
    }
}

运行后即可爬取这个网站中的身份证号码

3、爬虫的深入：

3.1 带条件的爬取（非捕获分组）

符号	含义	举例
(? : 正则）	获取所有	Java(?:8\|11\|17)
(? = 正则)	获取前面的部分	Java(?=8\|11\|17)
(? ! 正则)	获取不是指定内容的前面部分	Java(?!8\|11\|17)

演示代码：

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

public class RegexDemo05 {
    public static void main(String[] args) {
        // 带条件的爬取数据
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，"+
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        // 需求1：爬取版本号为8，11，17的Java文本，但是只要Java，不显示版本号。
        // 需求2：爬取版本号为8，11，17的Java文本。正确爬取结果为：Java8 Java11 Java17 Java17
        // 需求3：爬取除了版本号为8，11，17的Java文本

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

        // :表示获取整体所有的值
        String regex2 = "Java(?:8|11|17)";
//        String regex2 = "Java(8|11|17)";

        // !表示去除
        String regex3 = "Java(?!8|11|17)";
        Pattern p1 = Pattern.compile(regex3);
        Matcher m1 = p1.matcher(str);

        while(m1.find()) {
            System.out.println(m1.group());
        }
    }
}

3.2贪婪爬取和非贪婪爬取

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

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

演示代码：

public class RegexDemo06 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，abbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaa" +
                "经历了很多版本，目前企业中用的最多的是Java8和Java11，"+
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        // 贪婪爬取和非贪婪爬取


        // 创建正则表达式对象
        // 贪婪爬取
        Pattern p1 = Pattern.compile("ab+");// 会在下面输出： abbbbbbbbbb
        // 非贪婪爬取
        Pattern p2 = Pattern.compile("ab+?");// 会在下面输出： ab
        Matcher m = p2.matcher(str);
        while(m.find()) {
            System.out.println(m.group());
        }

    }
}

3.3分组

在这里插入图片描述

分组就是一个小括号
分组是有组号的，也就是序号。
- 规则一：从1开始，连续不间断
- 规则二：以左括号为基准，最左边的是第一组，其次为第二组，以此类推（嵌套小括号也是，只看左括号的顺序，在最左边就是第一个）

捕获分组和非捕获分组

捕获分组：(可以获取每组中的内容反复使用)
- 后续还要继续使用本组的数据。
- 正则内部使用：\\+组号
- 正则外部使用：$组号
非捕获分组：(分组之后不需要再用本组数据，仅仅是把数据括起来)
- 就是上面的三种（(?:)(?=)(?!)）带条件爬取数据（若要使用这些分组的数据会报错）

捕获分组的两个代码实例：

1、正则内部使用分组：

public class RegexDemo08 {
    public static void main(String[] args) {
        // 需求1：判断一个字符串的开始字符和结束字符是否一致？只考虑一个字符
        // 举例：a123a   b456b   17891   &abc&   a123b(false)
        //  \\+组号： 表示把第x组的内容再出来用一次
        String regex1 = "(.).+\\1";
        System.out.println("a123a".matches(regex1));    // true
        System.out.println("b456b".matches(regex1));    // true
        System.out.println("17891".matches(regex1));    // true
        System.out.println("&abc&".matches(regex1));    // true
        System.out.println("a123b".matches(regex1));    // false
        System.out.println("----------------------------------");

        // 需求2：判断一个字符串的开始部分和结束部分是否一致？可以有多个字符
        // 举例：abc123abc   b456b   123789123   &!@abc&!@   abc123abd(false)
        String regex2 = "(.+).+\\1";
        System.out.println("abc123abc".matches(regex2));    // true
        System.out.println("b456b".matches(regex2));    // true
        System.out.println("123789123".matches(regex2));    // true
        System.out.println("&!@abc&!@".matches(regex2));    // true
        System.out.println("abc123abd".matches(regex2));    // false
        System.out.println("----------------------------------");

        // 需求3：判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致
        // 举例：aaa123aaa   bbb456bbb   111789111   &&abc&&
        String regex3 = "((.)\\2).+\\1";
        System.out.println("aaa123aaa".matches(regex3));    // true
        System.out.println("bbb456bbb".matches(regex3));    // true
        System.out.println("111789111".matches(regex3));    // true
        System.out.println("&&abc&&".matches(regex3));    // true
        System.out.println("&&abc&*".matches(regex3));    // false
        System.out.println("----------------------------------");

    }
}

2、正则外部使用分组：

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

原文地址：https://blog.csdn.net/2302_81034736/article/details/143914411

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

上一篇：SpringMVC的视图
下一篇：vue2.0前端管理系统界面布局设置

【如何获取股票数据03】Python、Java等多种主流语言实例演示获取股票行情api接口之沪深A股实时最新分时MACD数据获取实例演示及接口API说明文档
目前分时级别支持5分钟、15分钟、30分钟、60分钟、日周月年级别（包括前后复权），对应的值分别是 5m（5分钟）、15m（15分钟）、30m（30分钟）、60m（60分钟）、dn(日线未复权)、
阅读更多2024-11-22
hj 212 协议解包php解包，
HJ212是由国家环保行业制定的数据传输标准协议，通常是通过TCP/P通讯方式进行数据传输的，数据传输报文主要由包头、数据段长度、数据段、CRC校验、包尾组成。重点解析的就是”数据段“的内容，内容包括
阅读更多2024-11-22
自适应安全框架（ASA）在网络安全2.0新防御体系中的应用
自适应安全框架（ASA）是Gartner于2014年提出的面向下一代的安全体系框架，以应对云大物移智时代所面临的安全形势。自适应安全框架（ASA）从预测、防御、检测、响应四个维度，强调安全防护是一个持
阅读更多2024-11-22
Python-基础
为了照顾现有程式，Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。7.可扩展：如果
阅读更多2024-11-22
第一次shell作业
echo "第一次shell作业" > /www/index.html。read -p"输入需要部署的服务名称: " server_name。echo &
阅读更多2024-11-22
【2024 Optimal Control 16-745】【Lecture 2】integrators.ipynb功能分析
l = 1.0g = 9.81θ = x[1] # 摆动角度 θθ̇ = x[2] # 摆动角速度 θ̇θ̈ = -(g / l) * sin(θ) # 根据摆动力学方程，计算角加速度 θ̈retur
阅读更多2024-11-22
原生微信小程序在顶部胶囊左侧水平设置自定义导航兼容各种手机模型
注意：红色阔里的是自定义导航（或者其他的logo啊，返回之类的都可以）；蓝色阔就是页面的内容模块。无论是在什么手机机型下，自定义的导航都和右侧的胶囊水平一条线上。注意：蓝色阔就是不胶囊，里面的值，就是
阅读更多2024-11-22
springboot高校毕业生实习及就业去向信息管理系统
本系统在一般高校毕业生实习及就业去向信息管理管理系统的基础上增加了首页推送最新信息的功能，方便用户快速浏览，是一个高效的、动态的、交互友好的高校毕业生实习及就业去向信息管理管理系统。系统的顺利开发和实
阅读更多2024-11-22
Leetcode704. 二分查找
leetcode704. 二分查找
阅读更多2024-11-22
django基于python 语言的酒店推荐系统
采用模块化设计方法实现一个复杂结构进行简化，分成一个个小的容易解决的板块，然后再将小的板块继续分化成功能单一的更小模块。[8]王玉芬,赵丹丹.基于Bootstrap和Django框架的Web计算器的设
阅读更多2024-11-22

Java的正则表达式和爬虫

正则表达式Regex和爬虫

一、正则表达式语法：

正则表达式在字符串方法中的使用：

二、爬虫：

1、本地爬虫

2、网络爬虫

3、爬虫的深入：

3.1 带条件的爬取（非捕获分组）

3.2贪婪爬取和非贪婪爬取

3.3分组

捕获分组和非捕获分组

相关文章

正则表达式`Regex`和爬虫