首页 > 其他分享 >爬虫

爬虫

时间：2024-11-16 15:41:03浏览次数：1  
标签：regex Java String System 爬虫 println out

程序示例:

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);

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

        // 方法底层会根据 find 方法记录的索引进行字符串的截取
        // substring(起始索引,结束索引);包头不包尾
        //(0,4)但是不包含 4 索引
        // 会把截取的小串进行返回. 
        String s1 = m.group();
        System.out.println(s1);  // Java
        // 第二次在调用 find 的时候,会继续读取后面的内容
        // 读取到第二个满足要求的子串,方法会继续返回 true
        // 并把第二个子串的起始索引和结束索引 +1,进行记录
        b = m.find();
        // 第二次调用 group 方法的时候,会根据 find 方法记录的索引再次截取子串
        String s2 = m.group();
        System.out.println(s2);  // Java8
    }
}

这样显然不可行, 需要用循环改写代码.

把原来的代码抽取出来形成一个方法放到外面, 但是并不去使用它. 改写代码:

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) {
        // 1.获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        // 2.获取文本匹配器的对象
        // 拿着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);  // Java
        // 第二次在调用find的时候,会继续读取后面的内容
        // 读取到第二个满足要求的子串,方法会继续返回true
        // 并把第二个子串的起始索引和结束索引+1,进行记录
        b = m.find();
        // 第二次调用group方法的时候,会根据find方法记录的索引再次截取子串
        String s2 = m.group();
        System.out.println(s2);  // Java8
    }
}

获取网络中的数据:

程序示例:

public class RegexDemo7 {
    public static void main(String[] args) throws IOException {
        /*
         * 扩展需求2:
         * https://www.bilibili.com/
         */

        // 创建一个URL对象
        URL url = new URL("https://www.bilibili.com/");
        // 连接上这个网址
        // 细节:保证网络是畅通
        URLConnection conn = url.openConnection();// 创建一个对象去读取网络中的数据
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();
    }
}

程序示例:

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

public class RegexDemo7 {
    public static void main(String[] args) throws IOException {
        /*
         * 扩展需求2:
         * 把连接:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i
         * 中所有的身份证号码都爬取出来. 
         */

        // 创建一个URL对象
        URL url = new URL("https://m.sengzan.com/jiaoyu/29104.html?ivk_sa=1025883i");
        // 连接上这个网址
        // 细节:保证网络是畅通
        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();
    }
}

程序示例:

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

public class RegexDemo8 {
    public static void main(String[] args) {
        /*
         * 需求:把下面文本中的座机电话, 邮箱, 手机号, 热线都爬取出来. 
         * 来黑马程序员学习Java, 
         * 手机号:18512516758, 18512508907或者联系邮箱:[email protected], 
         * 座机电话:01036517895, 010-98951256邮箱:[email protected], 
         * 热线电话:400-618-9090 , 400-618-4000, 4006184000, 4006189090
         *
         * 手机号的正则表达式:1[3-9]\d{9}
         * 邮箱的正则表达式:\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}座机电话的正则表达式:θ\d{2,3}-?[1-9]\
         * d{4,9}
         * 热线电话的正则表达式:400-?[1-9]\\d{2}-?[1-9]\\d{3}
         *
         */

        String s = "来黑马程序员学习Java, " +
                "电话:18512516758, 18512508907" + "或者联系邮箱:[email protected], " +
                "座机电话:01036517895, 010-98951256" + "邮箱:[email protected], " +
                "热线电话:400-618-9090 , 400-618-4000, 4006184000, 4006189090";

        System.out.println("400-618-9090");

        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.获取文本匹配器的对象
        // 利用m去读取s, 会按照p的规则找里面的小串
        Matcher m = p.matcher(s);
        // 3.利用循环获取每一个数据
        while (m.find()) {
            String str = m.group();
            System.out.println(str);
        }
    }
}

带条件的爬取

程序示例:

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

public class RegexDemo9 {
    public static void main(String[] args) {
        /*
         * 有如下文本, 按要求爬取数据. 
         * Java自从95年问世以来, 经历了很多版本, 目前企业中用的最多的是Java8和Java11, 
         * 因为这两个是长期支持版本, 下一个长期支持版本是Java17, 相信在未来不久Java17也会逐渐登上历史舞台
         *
         * 需求1:爬取版本号为8, 11.17的Java文本, 但是只要Java, 不显示版本号. 
         */
        String s = "Java自从95年问世以来, 经历了很多版本, 目前企业中用的最多的是Java8和Java11, " +
                "因为这两个是长期支持版本, 下一个长期支持版本是Java17, 相信在未来不久Java17也会逐渐登上历史舞台";

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

        String regex = "Java(?=8|11|17)";
        // 或者
        String regex1 = "((?i)Java)(?=8|11|17)";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s);
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

程序示例:

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

public class RegexDemo9 {
    public static void main(String[] args) {
        /*
         * 有如下文本, 按要求爬取数据. 
         * Java自从95年问世以来, 经历了很多版本, 目前企业中用的最多的是Java8和Java11, 
         * 因为这两个是长期支持版本, 下一个长期支持版本是Java17, 相信在未来不久Java17也会逐渐登上历史舞台
         *
         * 需求2:爬取版本号为8, 11, 17的Java文本. 正确爬取结果为:Java8 Java11 Java17 Java17
         */
        String s = "Java自从95年问世以来, 经历了很多版本, 目前企业中用的最多的是Java8和Java11, " +
                "因为这两个是长期支持版本, 下一个长期支持版本是Java17, 相信在未来不久Java17也会逐渐登上历史舞台";

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

        // 需求2:
        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());
        }
    }
}

程序示例:

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

public class RegexDemo9 {
    public static void main(String[] args) {
        /*
         * 有如下文本, 按要求爬取数据. 
         * Java自从95年问世以来, 经历了很多版本, 目前企业中用的最多的是Java8和Java11, 
         * 因为这两个是长期支持版本, 下一个长期支持版本是Java17, 相信在未来不久Java17也会逐渐登上历史舞台
         *
         * 需求3:爬取除了版本号为8, 11.17的Java文本
         */
        String s = "Java自从95年问世以来, 经历了很多版本, 目前企业中用的最多的是Java8和Java11, " +
                "因为这两个是长期支持版本, 下一个长期支持版本是Java17, 相信在未来不久Java17也会逐渐登上历史舞台";

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

        // 需求3:
        String regex4 = "((?i)Java)(?!8|11|17)";

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

贪婪爬取和非贪婪爬取

程序示例:

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

public class RegexDemo10 {
    public static void main(String[] args) {
        /*
         * 只写+和*表示贪婪匹配
         *
         * +? 非贪婪匹配
         * ? 非贪婪匹配
         *
         * 贪婪爬取:在爬取数据的时候尽可能的多获取数据
         * 非贪婪爬取:在爬取数据的时候尽可能的少获取数据
         *
         * ab+:
         * 贪婪爬取:abbbbbbbbbbbb
         * 非贪婪爬取:ab
         */
        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());  // abbbbbbbbbbbb
        }
    }
}

程序示例:

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

public class RegexDemo10 {
    public static void main(String[] args) {
        /*
         * 只写+和*表示贪婪匹配
         *
         * +? 非贪婪匹配
         * ? 非贪婪匹配
         *
         * 贪婪爬取:在爬取数据的时候尽可能的多获取数据
         * 非贪婪爬取:在爬取数据的时候尽可能的少获取数据
         *
         * ab+:
         * 贪婪爬取:abbbbbbbbbbbb
         * 非贪婪爬取:ab
         */
        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());  // ab
        }
    }
}

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

图片名称

程序示例:

public class RegexDemo11 {
    public static void main(String[] args) {
        // public string replaceAll(string regex,string newstr) : 按照正则表达式的规则进行替换
        // public string[] split(string regex) : 按照正则表达式的规则切割字符串

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

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

        String[] arr = s.split("[\\w&&[^_]]+");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

在 Java API 中, 如果一个方法的形参取名字叫 regex, 那么这个方法是能识别正则表达式的.

图片名称

 

图片名称

如果不识别正则表达式, 却传递了一个正则表达式, 则该正则表达式被识别为一个普通的字符串.

分组

分组就是小括号.

图片名称

每组是有组号的,也就是序号.

  • 规则1: 从 1 开始, 连续不间断.

  • 规则2: 以左括号为基准, 最左边的是第一组, 其次为第二组, 以此类推.

图片名称

 

图片名称

捕获分组就是把这一组的数据捕获出来, 再用一次.

程序示例:

public class RegexDemo12 {
    public static void main(String[] args) {
        // 需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
        // 举例: a123a b456b 17891 &abc& a123b(false)
        // \\组号:表示把第X组的内容再出来用一次
        String regex1 = "(.).+\\1";
        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,表示后面重复的内容出现日次或多次
        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("aaa123aab".matches(regex3));
    }
}

在正则表达式的外部, 也可以使用组里面的信息.

  • 正则内部使用: \\组号

  • 正则外部使用: $组号

程序示例:

public class RegexDemo13 {
    public static void main(String[] args) {
        /*
         * 需求:
         * 将字符串:我要学学编编编编程程程程程程替换为:我要学编程
         */
        String str = "我要学学编编编编程程程程程程";

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

非捕获分组不占用组号.

图片名称

程序示例:

public class RegexDemo14 {
    public static void main(String[] args) {
        /*
         *
         * 非捕获分组:分组之后不需要再用本组数据, 仅仅是把数据括起来. 
         *
         * 身份证号码:
         * 41080119930228457x51080119760902230915040119810705387X130133197204039024430102197606046442
         */
        // 身份证号码的简易正则表达式
        // 非捕获分组:仅仅是把数据括起来//特点:不占用组号
        // 这里\\1报错原因:(?:)就是非捕获分组, 此时是不占用组号的. 

        // (?:) (?=) (?!)都是非捕获分组
        // 更多的使用第一个
        // String regex1 ="[1-9]\\d{16}(?:\\d|x|x)\\1";  // 当使用 regex1 时报错: Unresolved back reference
        String regex2 = "[1-9]\\d{16}(\\d Xx)\\1";

        // System.out.println("41080119930228457x".matches(regex1));
        System.out.println("41080119930228457x".matches(regex2));
    }
}

标签：regex,Java,String,System,爬虫,println,out
From： https://www.cnblogs.com/Chengkai730/p/18549402

相关文章

  • 网络爬虫 Python 第二课
    BeautifulSoup高级用法：标签查找与筛选：除了简单地通过标签名查找（如 soup.find('div') 查找第一个 div 标签），还可以利用属性来更精准地查找。例如，如果要查找所有 class 属性为 article 的 div 标签，可以使用 soup.find_all('div',class_='article') 。这里注意 cl......
  • Python 网络爬虫入门教程
    引言网络爬虫（WebCrawler）是一种通过编程从互联网上抓取数据的技术，常用于数据分析、信息采集等任务。Python作为一门功能强大且易于使用的编程语言，拥有丰富的爬虫库和工具，如Requests、BeautifulSoup和Scrapy，使得网络爬虫的开发变得更加高效便捷。本文将以一个简单的实例，介......
  • 基于大数据 Python 歌曲筛选爬虫数据分析可视化系统(源码+LW+部署讲解+数据库+ppt)
    ！！！！！！！！！选题不知道怎么选不清楚自己适合做哪块内容都可以免费来问我避免后期給自己答辩找麻烦增加难度（部分学校只有一次答辩机会没弄好就延迟毕业了）会持续一直更新下去有问必答一键收藏关注不迷路源码获取：https://pan.baidu.com/s/1aRpOv3f2sdtVYOogQjb8jg?pwd=jf1d提取码:......
  • 如何用Java爬虫精准获取商品历史价格信息
    在数字化时代，商品价格信息的获取变得尤为重要。对于消费者来说，了解商品的历史价格趋势可以帮助他们做出更明智的购买决策。而对于商家来说，掌握价格数据则有助于制定更有效的销售策略。本文将详细介绍如何使用Java编写爬虫程序，精准获取商品的历史价格信息以及API数据。Java爬虫......
  • 使用Java爬虫技术高效获取电商平台商品历史价格信息
    在电商领域，商品的历史价格信息对于消费者制定购买决策具有重要意义。本文将介绍如何利用Java爬虫技术，通过API接口高效地获取店铺所有商品的详细信息。我们将使用Java语言，结合HttpClient库和JSON解析库，展示从API请求数据到数据处理的整个过程。理解API接口API（应用程序编程接......
  • 带你一起全面了解关于Python网络爬虫的相关知识点！
     成长路上不孤单......
  • 使用Java爬虫技术高效获取电商平台店铺商品数据
    在电商领域，商品信息的获取是进行市场分析、竞品监控等工作的基础。本文将介绍如何利用Java爬虫技术，通过API接口高效地获取店铺所有商品的详细信息。我们将使用Java语言，结合HttpClient库和JSON解析库，展示从API请求数据到数据处理的整个过程。理解API接口API（应用程序编程接口）允......
  • 探险家的秘密武器：Python爬虫
    在一个名为“代码王国”的神秘地方，有一位著名的探险家，他的名字叫“爬虫侠”。爬虫侠不是普通的探险家，他是一位Python程序员，擅长使用代码作为武器，探索未知的世界。今天，他接到了一个任务：从遥远的“电商星球”的店铺中，获取所有的商品信息。准备阶段：装备升级在出发前，爬虫侠需要......
  • python爬虫获得店铺的所有商品
    在编写Python爬虫以获取店铺的所有商品信息时，通常涉及到发送HTTP请求、解析响应内容以及处理API返回的数据。以下是一个详细的Python爬虫示例，用于获取店铺的商品信息。这个示例假设API返回的是JSON格式的数据，并且需要API密钥进行认证。步骤1：导入必要的库首先，需要导入Python......
  • 爬虫开发工具与环境搭建——开发工具介绍
    第二章：爬虫开发工具与环境搭建第一节开发工具介绍爬虫开发需要一些合适的工具和框架来高效地抓取网页数据。在这节中，我们将介绍常用的开发工具，帮助开发者快速搭建爬虫开发环境。1.Python与爬虫框架选择Python因其简洁、易学的语法以及强大的第三方库支持，成为了爬虫开发......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99