目录

• 爬虫
• • 本地爬虫和网络爬虫
  • 贪婪爬取和非贪婪爬取
  • 正则表达式在字符串方法中的使用
  • 捕获分组和非捕获分组
  • • 分组
    • 捕获分组
    • 非捕获分组

      爬虫

      本地爬虫和网络爬虫

      • 有如下文本，请按照要求爬取数据。（本地爬虫）

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

        要求：找出里面所有的JavaXX

        public static void main(String[] args) {
                /*有如下文本，请按照要求爬取数据。
                        Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，
                    下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台
                要求：找出里面所有的JavaXX*/
                String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本,下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        //        method1(str);
                //0.获取正则表达式对象
                Pattern p = Pattern.compile("Java\\d{0,2}");
                //1.获取文本匹配器的对象
                Matcher m = p.matcher(str);
                //2.利用循环获取匹配内容
                while (m.find()){
                    String s = m.group();
                    System.out.println(s);
                }
            }
            private static void method1(String str) {
                //获取正则表达式对象
                Pattern p = Pattern.compile("Java\\d{0,2}");
                //获取文本匹配器的对象
                //m:文本匹配器的对象
                //str:大串
                //p：规则
                //m要在str中找符合p规则的小串
                Matcher m = p.matcher(str);
                //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
                //如果没有，方法返回false
                //如果有，返回true，在底层记录子串的起始索引和结束索引+1
                boolean b = m.find();
                //方法底层会根据find方法记录的索引进行字符串的截取
                //subString(起始索引，结束索引）；包头不包尾
                //把截取的小串进行返回
                String s1 = m.group();
                System.out.println(s1);
                //第二次在调用find的时候，会继续读取后面的内容
                //读取到第二个满足要求的子串，方法会继续返回true
                //并把第二个子串的起始索引和结束索引+1，进行记录
                b = m.find();
                //第二次调用group方法的时候，会根据find方法记录的索引再次截取
                String s2 = m.group();
                System.out.println(s2);
            }
        

        ---

        注意：以下代码中的链接可能已经失效

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

        ---

        需求：

        ​ 有如下文本，按要求爬取数据。

        ​ 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文本。

        public static void main(String[] args) {
                String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是JAva8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。";
                //0.爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。
                System.out.println("0.爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。");
                String regex = "(?i)Java(?=8|11|17)";
                Pattern p = Pattern.compile(regex);
                Matcher m = p.matcher(str);
                while (m.find()){
                    String s = m.group();
                    System.out.println(s);
                }
                System.out.println("---------------------------------");
                //1.爬取版本号为8，11，17的Java文本。正确爬取结果为：JAva8 Java11 Java17 Java17
                System.out.println("爬取版本号为8，11，17的Java文本。正确爬取结果为：Java8 Java11 Java17 Java17");
                String regex2 = "(?i)Java(8|11|17)";
                String regex3 = "(?i)Java(?:8|11|17)";
                Pattern p2 = Pattern.compile(regex3);
                Matcher m2 = p2.matcher(str);
                while (m2.find()){
                    System.out.println(m2.group());
                }
                System.out.println("---------------------------");
                //2.爬取除了版本号为8，11，17的Java文本
                System.out.println("爬取除了版本号为8，11，17的Java文本");
                String regex4 = "(?i)Java(?!8|11|17)";
                Pattern p4 = Pattern.compile(regex4);
                Matcher m4 = p4.matcher(str);
                while (m4.find()){
                    System.out.println(m4.group());
                }
            }
        

        贪婪爬取和非贪婪爬取

        只写+和表示贪婪匹配，如果在+和后面加问号表示非贪婪爬取

        +? 非贪婪匹配

        *? 非贪婪匹配

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

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

        举例：

        如果获取数据：ab+

        贪婪爬取获取结果:abbbbbbbbbbbb

        非贪婪爬取获取结果:ab

            public static void main(String[] args) {
                String str = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
                //需求1:按照ab+的方式爬取ab，b尽可能多获取
                String regex = "ab+";
                Pattern p = Pattern.compile(regex);
                Matcher m = p.matcher(str);
                while (m.find()){
                    System.out.println(m.group());
                }
                //需求2:按照ab+的方式爬取ab，b尽可能少获取
                String regex2 = "ab+?";
                Pattern p2 = Pattern.compile(regex2);
                Matcher m2 = p2.matcher(str);
                while (m2.find()){
                    System.out.println(m2.group());
                }
            }
        

        ---

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

        

            public static void main(String[] args) {
                /*
                * 有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
                    要求1:把字符串中三个姓名之间的字母替换为vs
                    要求2:把字符串中的三个姓名切割出来
                * */
                String str = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
                //要求1:把字符串中三个姓名之间的字母替换为vs
                //按照正则表达式的规则进行替换
                /*
                * 细节：
                * 方法在底层跟之前一样也会创建文本解析器的对象
                * 然后从头开始去读取字符串中的内存，只要有满足的，那么就用第二个参数去替换
                * */
                String result = str.replaceAll("[\\w&&[^_]]+", "VS");
                System.out.println(result);  // 小诗诗VS小丹丹VS小惠惠
                //要求2:把字符串中的三个姓名切割出来
                //按照正则表达式的规则切割字符串
                String[] arr = str.split("[\\w&&[^_]]+");
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }
            }
        

        ---

        捕获分组和非捕获分组

        分组

        分组就是一个小括号

        

        每组是有组号的，也就是序号

        规则1： 从1开始，连续不间断

        规则2： 以左括号为基准，最左边的是第一组，其次为第二组，以此类推。

        捕获分组

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

        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&&
                //(.):把首字母看做一组
                // \\2:把首字母拿出来再次使用
                // *:作用于\\2,表示后面重复的内容出现日次或多次
                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("aa123bb".matches(regex3)); //false
            }
        

        后续还要继续使用本组的数据

        正则内部使用： \组号

        正则外部使用： $组号

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

        非捕获分组

        非捕获分组：分组之后不需要再用本组数据，仅仅是把数据括起来。

        特点:不占用组号

        

        //身份证号码的简易正则表达式
        //非捕获分组:仅仅是把数据括起来
        //特点:不占用组号
        //这里\1报错原因:(?:)就是非捕获分组，此时是不占用组号的。
        //(?:) (?=) (?!)都是非捕获分组//更多的使用第一个
        //String regex1 ="[1-9]\d{16}(?:\d|x|x)\1";
        String regex2 ="[1-9]\d{16}(\d Xx)\1";
        //^([01]\d|2[0-3]):[0-5]\d:[@-5]\d$
        System.out.println("41080119930228457x".matches(regex2));
        

         
         平面设计接单网  网页设计报价单  宁波网站建设活动  微信小程序怎么制作自己的程序  北京网站制作开发公司  龙岩做网站多少钱