java8新特性Stream流中anyMatch和allMatch和noneMatch的使用！！！

╰半夏微凉° 2024-03-27 15:30 7阅读 0赞

## 1、anyMatch ##

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

#### 接口定义： ####

boolean anyMatch(Predicate<? super T> predicate);

#### 方法描述： ####

在anyMatch 接口定义中是接收 Predicate 类型参数，在Lamdba表达式中 Predicate<T> 是接收一个T类型参数，然后经过逻辑验证返回布尔值结果。这里anyMatch表示，判断的条件里，任意一个元素符合条件，就返回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 a1() {
            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 a2() {
            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值。

#### 适用场景： ####

两个集合的差集

.........

@Test
    public void a1() {
            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 a2() {
            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 a3() {
            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
    }