Java8新特性Stream流中anyMatch和allMatch和noneMatch的区别解析

 更新时间:2024年01月19日 14:38:49   作者:致最长的电影  
这篇文章主要介绍了Java8新特性Stream流中anyMatch和allMatch和noneMatch的区别解析,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧

1、anyMatch 

判断数据列表中是否存在任意一个元素符合设置的predicate条件,如果是就返回true,否则返回false。

  • 接口定义:
    • boolean anyMatch(Predicate<? super T> predicate);
  • 方法描述:
    • 在anyMatch 接口定义中是接收 Predicate 类型参数,在Lamdba表达式中 Predicate<T> 是接收一个T类型参数,然后经过逻辑验证返回布尔值结果。这里anyMatch表示,判断的条件里,任意一个元素符合条件,就返回true值。
  • 使用场景:
    • 两个集合的交集
    @Test
    public void a17() {
        List<User> list = new ArrayList<>();
        list.add(new User("张三", 12, "南京"));
        list.add(new User("李四", 13, "北京"));
        list.add(new User("王五", 14, "苏州"));
        list.add(new User("王五", 17, "苏州"));
        List<User> userList = new ArrayList<>();
        userList.add(new User("李四", 13, "北京"));
        userList.add(new User("王五", 20, "广州"));
        // 获取两个集合中有相同名字或者年龄相同的,只要满足其中一个条件即可,只会返回list集合里面的元素,有先后顺序返回
        List<User> users1 = list.stream()
                .filter(a -> userList.stream().anyMatch(b -> a.getName().equals(b.getName()) || a.getAge() == b.getAge()))
                .collect(Collectors.toList());
        // 获取两个集合中相同名字并且年龄相同的,必须同时满足两个条件
        List<User> users2 = list.stream()
                .filter(a -> userList.stream().anyMatch(b -> a.getName().equals(b.getName()) && a.getAge() == b.getAge()))
                .collect(Collectors.toList());
        users1.forEach(item -> {
            System.out.println(item.getName() + item.getAge() + item.getEmailAddress());
        });
        /** 第一种结果展示:
         * 李四13北京
         * 王五14苏州
         * 王五17苏州
         */
        users2.forEach(item -> {
            System.out.println(item.getName() + item.getAge() + item.getEmailAddress());
        });
        /** 第二种结果展示:
         * 李四13北京
         */
    }
@Test
public void a15() {
        Stream<String> stream = Stream.of("ac", "bcddddd", "bd");
        // 判断stream中其中任何一个元素中只要有包含b字符串或者l字符串就返回true
        boolean isMatch = stream.anyMatch(str -> str.contains("b") || str.contains("l"));
        System.out.println(isMatch);  // true
}

2、allMatch

判断数据列表中全部元素都符合设置的predicate条件,如果是就返回true,否则返回false,流为空时总是返回true。

  • 接口定义:
    • boolean allMatch(Predicate<? super T> predicate);
  • 方法描述:
    • 在allMatch 接口定义中是接收 Predicate 类型参数,在Lamdba表达式中 Predicate<T> 是接收一个T类型参数,然后经过逻辑验证返回布尔值结果。这里allMatch表示,判断的条件里,全部元素符合条件,就返回true值。
  • 适用场景:
    • 基本类型的集合,但不适合于对象集合(我自己的理解)
    • allMatch里面不适合写 && ,只适合写 ||,如果写&&,编译器会自动报黄色波浪线
@Test
public void a18() {
        List<String> typeList1 = Arrays.asList("1", "2");
        List<String> typeList2 = Arrays.asList("1", "2", "3", "4");
        // 集合列表中全部元素必须在allMatch里面的那些字符串,只要全部元素中有任意一个不同的元素在AllMatch中就返回false
        boolean isMatch1 = typeList1.stream().allMatch(a -> a.equals("1") || a.equals("2") || a.equals("3"));
        boolean isMatch2 = typeList2.stream().allMatch(a -> a.equals("1") || a.equals("2") || a.equals("3"));
        System.out.println(isMatch1);   // true
        System.out.println(isMatch2);   // false
}
@Test
public void a16() {
        Stream<String> stream = Stream.of("abc", "abc", "bcd");
        // 判断stream中全部所有元素必须全部包含b字符串和c字符串就返回true,如果有一个元素不包含这两个字符串就返回false
        boolean isMatch = stream.allMatch(str -> str.contains("b") && str.contains("c"));
        System.out.println(isMatch);  // true
}

3、noneMatch

判断数据列表中全部元素都不符合设置的predicate条件,如果是就返回true,否则返回false,流为空时总是返回true。

  • 接口定义:
    • boolean noneMatch(Predicate<? super T> predicate);
  • 方法描述:
    • 在noneMatch接口定义中是接收 Predicate 类型参数,在Lamdba表达式中 Predicate<T> 是接收一个T类型参数,然后经过逻辑验证返回布尔值结果。这里noneMatch表示与allMatch相反,判断的条件里的元素,所有的元素都不符合,就返回true值。
  • 适用场景:
    • 两个集合的差集 (本人只想到这么做,如果有更简洁的可以告诉我怎么写,感谢0.0)
@Test
public void a17() {
        List<User> list = new ArrayList<>();
        list.add(new User("张三", 12, "南京"));
        list.add(new User("李四", 13, "北京"));
        list.add(new User("王五", 14, "苏州"));
        list.add(new User("王五", 17, "苏州"));
        List<User> userList = new ArrayList<>();
        userList.add(new User("李四", 13, "北京"));
        userList.add(new User("王五", 20, "广州"));
        // 获取list集合和userList集合过滤掉两者集合中名字和年龄相同的数据后,只返回list集合的数据
        List<User> users3 = list.stream()
                .filter(a -> userList.stream().noneMatch(b -> a.getName().equals(b.getName()) && a.getAge() == b.getAge()))
                .collect(Collectors.toList());
        // 获取userlist集合和list集合过滤掉两者集合中名字和年龄相同的数据后,只返回userList集合的数据
        List<User> users4 = userList.stream()
                .filter(a -> list.stream().noneMatch(b -> a.getName().equals(b.getName()) && a.getAge()==b.getAge()))
                .collect(Collectors.toList());
        // 获取list和userList集合之间的差集,将上面两者集合合并,就是两个集合的差集
        List<User> arrayList = new ArrayList<>();
        arrayList.addAll(users3);
        arrayList.addAll(users4);
        arrayList.forEach(item -> {
            System.out.println(item.getName() + item.getAge() + item.getEmailAddress());
        });
        /**  两者集合之间的差集
         * 张三12南京
         * 王五14苏州
         * 王五17苏州
         * 王五20广州
         */
        System.out.println("-------------------");
        users3.forEach(item -> {
            System.out.println(item.getName() + item.getAge() + item.getEmailAddress());
        });
        /**  只返回list集合中过滤掉之后的元素集合
         * 张三12南京
         * 王五14苏州
         * 王五17苏州
         */
        System.out.println("-------------------");
        users4.forEach(item -> {
            System.out.println(item.getName() + item.getAge() + item.getEmailAddress());
        });
        /**  只返回userList集合中过滤掉之后的元素集合
         * 王五20广州
         */
}
@Test
public void a19() {
        List<String> typeList1 = Arrays.asList("1", "2");
        List<String> typeList2 = Arrays.asList("1", "2", "3", "4");
        // 集合列表中全部元素只要都不在noneMatch里面的判断中,就返回true,集合列表中任何元素中只要有一个在noneMatch的判断中就返回false
        boolean isMatch1 = typeList1.stream().noneMatch(a -> a.equals("3") || a.equals("4"));
        boolean isMatch2 = typeList2.stream().noneMatch(a -> a.equals("1") || a.equals("2") || a.equals("3"));
        System.out.println(isMatch1);   // true
        System.out.println(isMatch2);   // false
}
/** noneMatch */
@Test
public void a20() {
        Stream<String> stream = Stream.of("dddd", "ee", "qqq", "bcfff");
        // 判断 stream 中所有的元素都不是以 a 开头,就返回true,如果所有的元素中只要其中一个元素是以a开头的,就返回false
        boolean isMatch = stream.noneMatch(str->str.startsWith("a"));
        System.out.println(isMatch);  // true
}

到此这篇关于Java8新特性Stream流中anyMatch和allMatch和noneMatch的区别详解的文章就介绍到这了,更多相关java8 anyMatch和allMatch和noneMatch区别内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • Java编程中的HashSet和BitSet详解

    Java编程中的HashSet和BitSet详解

    这篇文章主要介绍了Java编程中的HashSet和BitSet详解的相关资料,需要的朋友可以参考下
    2017-03-03
  • 值得收藏!教你如何在IDEA中快速查看Java字节码

    值得收藏!教你如何在IDEA中快速查看Java字节码

    开发中如果我们想看JVM虚拟机怎么编译我们的Java文件,生成字节码的,用IDEA工具就可以查看,本篇文章就给大家详细介绍,对正在学习java的小伙伴们很有帮助,需要的朋友可以参考下
    2021-05-05
  • Spring Bean是如何初始化的详解

    Spring Bean是如何初始化的详解

    Spring只Bean加载机制默认情况下是初始化容器的时候就会直接初始化,但是也取决于是否使用了懒加载,下面这篇文章主要给大家介绍了关于Spring Bean是如何初始化的相关资料,需要的朋友可以参考下
    2022-03-03
  • SpringBoot整合Mybatis-Plus分页失效的解决

    SpringBoot整合Mybatis-Plus分页失效的解决

    本文主要介绍了SpringBoot整合Mybatis-Plus分页失效的解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-01-01
  • SpringBoot使用JavaCV处理rtsp流的示例代码

    SpringBoot使用JavaCV处理rtsp流的示例代码

    这篇文章主要为大家详细介绍了SpringBoot使用JavaCV处理rtsp流,文中的示例代码讲解详细,具有一定的参考价值,感兴趣的小伙伴可以跟随小编一起了解一下
    2024-02-02
  • 进一步理解Java中的多态概念

    进一步理解Java中的多态概念

    这篇文章主要介绍了进一步理解Java中的多态概念,是Java入门学习中的基础知识,需要的朋友可以参考下
    2015-08-08
  • Java异常处理实例分析

    Java异常处理实例分析

    这篇文章主要介绍了Java异常处理,实例分析了java异常处理的常见用法,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-04-04
  • 基于Transactional事务的使用以及注意说明

    基于Transactional事务的使用以及注意说明

    这篇文章主要介绍了Transactional事务的使用以及注意说明,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-07-07
  • JAVA+Hibernate 无限级分类

    JAVA+Hibernate 无限级分类

    主要看menu_id和parent_id这两个字段。 Eclipse生成的表持久映射:(说明:自己加level属性,作用:为了记录种类所在深度)
    2008-07-07
  • 利用Jmeter发送Java请求的实战记录

    利用Jmeter发送Java请求的实战记录

    JMeter是Apache组织的开放源代码项目,它是功能和性能测试的工具,100%的用java实现,下面这篇文章主要给大家介绍了关于如何利用Jmeter发送Java请求的相关资料,需要的朋友可以参考下
    2021-09-09

最新评论