当前位置：首页 > article >正文

Java----用正则表达式爬取数据

article 2025/4/1 3:19:22

爬虫，也称为网络爬虫（Web Crawler）或网络蜘蛛（Web Spider），是一种按照一定规则，自动抓取万维网信息的程序或脚本。它通过模拟人类在浏览器中的操作，访问网页并解析其中的内容，将有用的数据提取出来。

Pattern.compile()方法属于java.util.regex.Pattern类，其主要功能是将一个正则表达式字符串编译成Pattern对象。编译后的Pattern对象可用于创建Matcher对象，进而执行匹配操作。将正则表达式编译为Pattern对象这一步骤并非必需，但如果需要多次使用同一个正则表达式进行匹配，提前编译可以显著提高性能，因为编译过程相对耗时。

import java.util.regex.Pattern;

public class PatternCompileExample {
    public static void main(String[] args) {
        // 编译正则表达式，匹配连续的数字
        Pattern pattern = Pattern.compile("\\d+");
        System.out.println("正则表达式已编译为Pattern对象");
    }
}

在上述代码中，Pattern.compile("\\d+")将正则表达式\\d+（用于匹配一个或多个连续数字）编译成了Pattern对象，后续就可以利用这个对象进行相关匹配操作。

Matcher.group()方法是Matcher类中的重要方法，用于获取匹配到的子字符串。它可以有两种使用方式：不带参数和带参数。不带参数时，返回上一次匹配操作所匹配到的整个字符串；带参数时，参数代表捕获组的编号，返回对应捕获组匹配到的子字符串。捕获组是通过在正则表达式中使用括号()定义的，捕获组编号从 1 开始，group(0)等同于无参数的group()，表示整个匹配的字符串。

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.Math.abs;
import static java.lang.Math.random;

    public class Test3 {
        public  static void main(String[] args) {
            //1.获取正则表达式的对象
            //2.获取文本匹配器的对象
            //拿着m去读取str，找符合p规则的字串
            String s="来黑马程序员学习Java,\n" +
                    "电话：18512516758，18512508907\n" +
                    "或者联系邮箱：boniu@itcast.cn,\n" +
                    "座机电话：01036517895，010-98951256\n" +
                    "邮箱：bozai@itcast.cn,\n" +
                    "热线电话：400-618-9090，400-618-4000,4006184000，4006189090";
//            String regex1 = "400-?[1-9]//d{2}-[1-9]//d{3}";
//            String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
//            String regex3 = "1[3-9]\\d{9}";
//            String regex4 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
            String regex = "(400-?[1-9]//d{2}-[1-9]//d{3})|" +
                    "(0\\d{2,3}-?[1-9]\\d{4,9})|" +
                    "(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2})";
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(s);
            while (m.find()){
                String s1 = m.group();
                System.out.println(s1);
            }


        }

    }

Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17

需求:爬取版本号为8,11,17的Java文本，但是只要Java，不显示版本号。

1.定义正则表达式
?理解为前面的数据Java
=表示在JaVa后面要跟随的数据
但是在获取的时候，只获取前半部分

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.Math.abs;
import static java.lang.Math.random;

    public class Test3 {
        public  static void main(String[] args) {
            //1.获取正则表达式的对象
            //2.获取文本匹配器的对象
            //拿着m去读取str，找符合p规则的字串
            String s="Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                    "因为这两个是长期支持版本，下一个长期支持版本是Java17";
//            String regex1 = "400-?[1-9]//d{2}-[1-9]//d{3}";
//            String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
//            String regex3 = "1[3-9]\\d{9}";
//            String regex4 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
            String regex = "Java(?=8|11|17)";
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(s);
            while (m.find()){
                String s1 = m.group();
                System.out.println(s1);
            }


        }

    }

贪婪爬取：

贪婪爬取是正则表达式的默认匹配模式。在这种模式下，正则表达式会从字符串的起始位置开始，尽可能多地匹配符合模式的字符，直到无法再匹配为止。例如，对于正则表达式a.*b，它会在字符串中寻找以a开头、以b结尾的最长子串。（经可能多的爬取）

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.Math.abs;
import static java.lang.Math.random;

    public class Test3 {
        public  static void main(String[] args) {
            //1.获取正则表达式的对象
            //2.获取文本匹配器的对象
            //拿着m去读取str，找符合p规则的字串
            String s="Java自从95年问世以来，abbbbbbbbbbbbbbbbbbbbaaaaaaaaaaa经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                    "因为这两个是长期支持版本，下一个长期支持版本是Java17";
            String regex = "ab+";
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(s);
            while (m.find()){
                String s1 = m.group();
                System.out.println(s1);
            }


        }

    }

非贪婪爬取：

非贪婪爬取，也称为懒惰匹配，与贪婪爬取相反。在这种模式下，正则表达式会从字符串的起始位置开始，尽可能少地匹配符合模式的字符，一旦找到一个能满足匹配条件的最小子串，就停止匹配。在正则表达式中，通过在量词（如*、+、?）后面加上?来实现非贪婪匹配。例如，a.*?b表示匹配以a开头、以b结尾的最短子串。（尽可能少的爬取）

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.Math.abs;
import static java.lang.Math.random;

    public class Test3 {
        public  static void main(String[] args) {
            //1.获取正则表达式的对象
            //2.获取文本匹配器的对象
            //拿着m去读取str，找符合p规则的字串
            String s="Java自从95年问世以来，abbbbbbbbbbbbbbbbbbbbaaaaaaaaaaa经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                    "因为这两个是长期支持版本，下一个长期支持版本是Java17";
            String regex = "ab+?";
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(s);
            while (m.find()){
                String s1 = m.group();
                System.out.println(s1);
            }


        }

    }