正则表达式和lambda表达式

1. 正则表达式

1. 正则表达式可以校验字符串是否满足一定的规则, 并用来校验数据格式的合法性

2. 正则表达式的作用:

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

2. 正则表达式匹配

正则表达式中[]表示一个要求的范围

2.1 字符类(只匹配一个字符)

忽略b的大小写, 使用(?i)

  String regex1 = "a((?i)b)c";

// 只能是 a b c
        System.out.println("------------1------------");
        System.out.println("a".matches("[abc]")); // true
        System.out.println("z".matches("[abc]")); // false
        System.out.println("ab".matches("[abc]")); // false
        System.out.println("ab".matches("[abc][abc]")); // true

        // 不能是 a b c
        System.out.println("------------2------------");
        System.out.println("a".matches("[^abc]")); // false
        System.out.println("z".matches("[^abc]")); // true
        System.out.println("zz".matches("[^abc]")); // false
        System.out.println("zz".matches("[^abc][^abc]")); // true

        // a到z A到Z
        System.out.println("------------3------------");
        System.out.println("a".matches("[a-zA-Z]")); // true
        System.out.println("aa".matches("[a-zA-Z][a-zA-Z]")); // true
        System.out.println("0".matches("[a-zA-Z]")); // false

        // 提高可读性, 用括号括起来, 同样达到上面效果
        System.out.println("------------4------------");
        System.out.println("a".matches("[a-d[m-p]]")); // true
        System.out.println("z".matches("[a-d[m-p]]")); // false

        // && 求交集, 如果写出一个&, 仅代表该符号
        System.out.println("------------5------------");
        System.out.println("a".matches("[a-z&&[def]]")); // false
        System.out.println("d".matches("[a-z&&[def]]")); // true

        // [a-z&&[^bc]] 匹配 a-z 中除了 b c 的字符
        System.out.println("------------6------------");
        System.out.println("a".matches("[a-z&&[^bc]]")); // true
        System.out.println("b".matches("[a-z&&[^bc]]")); // false

        // [a-z&&[^m-p]] 匹配 a-z 中除了 m-p 的字符
        System.out.println("------------7------------");
        System.out.println("a".matches("[a-z&&[^m-p]]")); // true
        System.out.println("m".matches("[a-z&&[^m-p]]")); // false

2.2 预定义字符(只匹配一个字符)

2.3 匹配多个字符

// 必须是字母 数字 下划线 出现次数最少6位
        System.out.println("asafasd_213".matches("\\w{6,}")); // true
        System.out.println("asd_".matches("\\w{6,}")); // false

        // 必须是数字和字符 必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}")); // true
        System.out.println("2_dF".matches("[a-zA-Z0-9]{4}")); // false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}")); // true
        System.out.println("2_dF".matches("[\\w&&[^_]]{4}")); // false

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

String s = "小诗诗dsadsaf123小丹丹dlsafkl小强强";
        // 1.把字符串中三个姓名之间的字母替换为vs
        String res = s.replaceAll("[\\w&&[^_]]+", "vs");
        System.out.println(res);


        // 2.把字符串中的三个姓名切割出来
        String[] names = s.split("[\\w&&[^_]]+");
        for (String name : names) {
            System.out.println(name);
        }

2.5 分组

2.5.1 捕获分组

1. 定义

1. 正则内部使用\组号, 正则外部使用$组号
   
   

2. 判断一个字符串的开始字符和结束字符是否一致(只考虑一个字符)

// 组号: 表示把第x组的内容拿出来用
        String regex1 = "(.).+\\1";
        System.out.println("a123a".matches(regex1)); // true
        System.out.println("bsad@b".matches(regex1));  // true
        System.out.println("a123b".matches(regex1)); // false     

3. 判断一个字符串的开始部分和结束部分是否一致(可以有多个字符)

String regex2 = "(.+).+\\1";
        System.out.println("ab123ab".matches(regex2)); // true
        System.out.println("bsad@b".matches(regex2));  // true
        System.out.println("aa123ab".matches(regex2)); // false

4. 判断一个字符串的开始部分和结束部分是否一致(开始部分每个字符也需要一致)

String regex3 = "((.)(\\2)*).+\\1";
        System.out.println("aa123aa".matches(regex3)); // true
        System.out.println("ab123ab".matches(regex3)); // false
        System.out.println("bsad@b".matches(regex3));  // true
        System.out.println("aa123ab".matches(regex3)); // false

2.5.2 非捕获分组

2.6 使用有效插件

any-rule

2.7 身份证号码的简单校验

2.8 正则表达式小结

3. 爬虫

3.1 基本爬虫

3.2 有条件的爬取

• 使用?占位符匹配, 但是输出不显示该部分内容, ?!进行排除, ?:等同于不写
  

3.2 贪婪爬取和非贪婪爬取

1. 贪婪爬取: 在爬取数据的时候尽可能多得获取数据
2. 非贪婪爬取: 在爬取数据的时候尽可能少得获取数据
   eg. ab+
   贪婪爬取: abbbbbbbbbbb 非贪婪爬取: ab
   3. Java当中, 默认的就是贪婪爬取, 如果在数量词+或者*的后面加上问号, 此时就是非贪婪爬取
3. 只写+和*表示贪婪爬取 +? 和 *? 表示非贪婪爬取
   

       String s = "abbbbbbbbbbbbbb";
//        Pattern p = Pattern.compile("ab+");  // abbbbbbbbbbbbbb
//        Pattern p = Pattern.compile("ab+?"); // ab
        Pattern p = Pattern.compile("ab*"); // abbbbbbbbbbbbbb
//        Pattern p = Pattern.compile("ab*?"); // a
        Matcher m = p.matcher(s);
        while(m.find()){
            System.out.println(m.group());
        }

2. lambda表达式

2.1 lambda表达式基本用法和好处

1. Lambda表达式的作用: 简化函数式接口的匿名内部类的写法

2. Lambda表达式使用前提: 必须是接口的匿名内部类, 接口中只能有一个抽象方法
   
   
   

3. Lambda表达式的好处:

• Lambda是一个匿名函数, 我们可以把Lambda表达式理解为是一段可以传递的代码, 它可以写出更简洁, 更灵活的代码, 作为一种更紧凑的代码风格, 使Java语言表达能力得到了提升

2.2 lambda表达式的省略写法

1. 省略核心: 可推到, 可省略