爬取，带条件爬取，贪婪爬取，分组

最新推荐文章于 2024-07-19 17:37:28 发布

小仙女-仙

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量98

点赞数

文章标签： java 正则表达式开发语言

本文链接：https://blog.csdn.net/m0_74075337/article/details/129345889

版权

一爬取

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

public class RegexDemo4 {
    public static void main(String[] args) {
        String str = "java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台；";
        //method1(str);
        //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}");
        Matcher m = p.matcher(str);
        /*
        获取文本匹配器的对象；
        m:
        文本匹配器的对象；
        str:
        大串；
        p:
        规则；
         */
        Boolean b = m.find();
        //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串；
        //要是没有，返回false，
        // 有的话，返回true；在底层记录子串的起始索引和结束索引+1；
        String s1 = m.group();
        System.out.println(s1);
        //方法底层会根据find方法记录的索引进行字符串的截取；
        //subString(起始索引，结束索引）；包头不包尾；
        //(0,4)但是不包含4索引；

        b = m.find();
        //第二次调用find方法；就继续读取；
        //读取到第二个满足要求的子串，方法继续返回true；
        //并把第二个子串的起始索引和技术索引+1，进行记录；
        String s2 = m.group();
        System.out.println(s2);

    }
}

二带条件爬取

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也会逐渐登上历史舞台；
                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后面要跟随的数据；
        //但是在获取的时候，只获取前半部分；
        String regex1="Java(?=8|11|17)";
        //1.
        //String regex2="((?i)Java)(8|11|17)";
        //2.忽略Java大小写，输出带有8，11，17的；
        String regex3="((?i)Java)(?:8|11|17)";
        //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());

        }

    }
}

三贪婪爬取和非贪婪爬取

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

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

java中默认贪婪爬取,如果我们在数量词+*的后面加上问号，那么此时就是非贪婪爬取；

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

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

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

public String replaceAll(String regex,String newStr) 按照正则表达式的规则替换

public String[] split(String regex) 按照正则表达式的规则切割字符串

public class RegexDemo8 {
    public static void main(String[] args) {
        String s="小诗诗dqwefqwfwq12312小丹丹dqwefqwfwq12312小惠惠";
        String result = s.replaceAll("[\\w&&[^_]]+", "vs");
        System.out.println(result);
        //按照正则表达式进行替换；
        //方法在底层跟之前一样，也会创建文本解析器的对象；
        //然后从头开始去读取字符串的内容，只要有满足的，就用第二个参数去替换；
        String[] arr = s.split("[\\w&&[^_]]+");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);

        }

    }
}

五分组

分组就是一个小括号

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

从1开始，连续不间断；
以左括号为基准，最左边的是第一组，其次为第二组，以此类推；
(\\d+)(\\d+)(\\d+)
(\\d+(\\d+))(\\d+)
第一组第二组第三组

（一）捕获分组的练习

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

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

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

        //3.判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致；
        //要求一致时，用到捕获分组；
        String regex3="((.)\\2*).+\\1";
        //*表示0次或者多次；
        //(.)：把首字母看作一组；
        // \\2表示把首字母拿出来再次使用；
        //*:作用于\\2,表示后面重复的内容出现0次或多次；
        System.out.println("aaa123aaa".matches(regex3));


    }
}

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

捕获分组：

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

正则内部使用：\\组号

正则外部使用：$组号

（二）非捕获分组

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

public class RegexDemo11 {
    public static void main(String[] args) {
        //身份证号码的简易正则表达式；
        String regex="[1-9]\\d{16}(？：\\d|X|x)";
        //非捕获分组：仅仅是把数据括起来
        //特点：不占用组号；
        System.out.println("21092120040938002X".matches(regex));
        //(?:)  (?=)  (?!)都是非捕获分组；
        //更多的使用第一个；

    }
}

小仙女-仙

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
爬取，带条件爬取，贪婪爬取，分组

public String replaceAll(String regex,String newStr) 按照正则表达式的规则替换。java中默认贪婪爬取,如果我们在数量词+*的后面加上问号，那么此时就是非贪婪爬取；非捕获分组：分组之后不需要再用本组数据，仅仅是把数据括起来；非贪婪爬取：在爬取数据的时候尽可能地少获取数据；贪婪爬取：在爬取数据的时候尽可能地多获取数据；捕获分组就是把这一组的数据捕获出来，再用一次；每组是有括号的，也就是序号；后续还要继续使用本组的数据。正则内部使用：\\组号。
复制链接

扫一扫