stream流：交集、差集、取集合某个字段、排序的举例

stream流常用的一些操作

• 交集
• 差集
• 取集合某个字段
• 集合排序

PS：不喜欢看概念可以直接去看源码示例

anyMatch（交集）

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

• 接口定义：

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

• 方法描述：
  • 在anyMatch 接口定义中是接收 Predicate 类型参数，在Lamdba表达式中 Predicate<T> 是接收一个T类型参数，然后经过逻辑验证返回布尔值结果。这里anyMatch表示，判断的条件里，任意一个元素符合条件，就返回true值。

• 使用场景：
  • 两个集合的交集

noneMatch（差集）

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

• 接口定义：
  • boolean noneMatch(Predicate<? super T> predicate);

• 方法描述：
  • 在noneMatch接口定义中是接收 Predicate 类型参数，在Lamdba表达式中 Predicate<T> 是接收一个T类型参数，然后经过逻辑验证返回布尔值结果。这里noneMatch表示与allMatch相反，判断的条件里的元素，所有的元素都不符合，就返回true值。
• 适用场景：
  • 两个集合的差集

源码：

Stream

package com.loong.test.stream;

import java.util.*;
import java.util.stream.Collectors;

/**
 * stream流：交集、差集、取集合某个字段、排序的举例
 *
 * @Author: loong
 * @Date: 2023-09-22
 */
public class basicEg {
    public static void main(String[] args) {
        // 集合A
        ArrayList<User> userListA = new ArrayList<>();
        userListA.add(new User(1L, "张三", 18,1));
        userListA.add(new User(2L, "李四", 19,1));
        userListA.add(new User(3L, "王二", 20,1));

        //集合B
        ArrayList<User> userListB = new ArrayList<>();
        userListB.add(new User(1L, "张三", null,1));
        userListB.add(new User(3L, "王二", 22,1));

        // 取交集  A∩B，以userId相等和年龄为空作为判断依据（两个条件都要满足），并且将集合B中的年龄以A集合为例补全作为新的集合
        List<User> aIntersectB = userListB.stream()
                .filter(userB -> userListB.stream()
                        .anyMatch(userA ->
                                Objects.equals(userB.getUserId(), userA.getUserId())
                                        && Objects.isNull(userB.getAge())
                        )).collect(Collectors.toList());
        System.out.println("aIntersectB = " + aIntersectB);


        // 取差集 A\B，以userI的作为判断依据，元素属于集合A，但是不属于集合B的元素拿出来作为新的集合
        List<User> aDiffB = userListA.stream()
                .filter(userA -> userListB.stream()
                        .noneMatch(userB ->
                                Objects.equals(userA.getUserId(), userB.getUserId()))).collect(Collectors.toList());

        System.out.println("aDiffB = " + aDiffB);

        // 取集合某个字段 取A集合中的userId作为新的集合
        List<Long> userIdListA = userListA.stream().map(User::getUserId).collect(Collectors.toList());
        System.out.println("userIdListA = " + userIdListA);


        System.out.println("\n-------------------------------漂亮的分割线，下面是排序的----------------------------------------\n");

        /**
         * 升序 = 正序
         * 降序 = 倒序
         * 升序默认
         * 降序加 reversed() 或 Comparator.reverseOrder()
         * -------------------------------------------------------
         * 关于 reversed() 和 Comparator.reverseOrder()的使用建议总结
         * 1.多个条件都为降序,则 reversed() 应该写在最后
         * 2.多个排序条件的排序方向不一致，需要倒序的字段应该用 Comparator.reverseOrder()
         * 3.两个方法加的位置不一样注意辨识
         */
        // 集合C
        ArrayList<User> userListC= new ArrayList<>();
        userListC.add(new User(1L, "张三", 18,1));
        userListC.add(new User(2L, "李四", 22,1));
        userListC.add(new User(3L, "王二", 19,1));
        userListC.add(new User(4L, "沈六", 19,0));

        // 将集合C以年龄排升序得到新的集合，默认升序，所以只用Comparator.comparing(User::getAge)即可
        List<User> cOrderByAgeAsc = userListC.stream()
                .sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
        System.out.println("cOrderByAgeAsc = " + cOrderByAgeAsc);

        // 将集合C以年龄排降序得到新的集合，方式1：降序需要加reversed()
        List<User> cOrderByAgeDesc = userListC.stream()
                .sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
        System.out.println("cOrderByAgeDesc = " + cOrderByAgeDesc);

        // 将集合C以年龄排降序得到新的集合，方式2：降序需要加Comparator.reverseOrder()
        List<User> cOrderByAgeDesc2 = userListC.stream()
                .sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println("cOrderByAgeDesc = " + cOrderByAgeDesc2);

        // 将集合C以年龄排降序，并且以状态排升序
        List<User> cOrderByAgeDescAndStatusAsc = userListC.stream()
                .sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder())
                        .thenComparing(User::getStatus)).collect(Collectors.toList());
        System.out.println("cOrderByAgeDescAndStatusAsc = " + cOrderByAgeDescAndStatusAsc);

        // 将集合C以年龄排降序，并且以状态也排降序
        List<User> cOrderByAgeDescAndStatusDAsc = userListC.stream().
                sorted(Comparator.comparing(User::getAge)
                        .thenComparing(User::getStatus).reversed()).collect(Collectors.toList());

        System.out.println("cOrderByAgeDescAndStatusDAsc = " + cOrderByAgeDescAndStatusDAsc);
        System.out.println("断点打在这里有助于观察集合内容哦~");

    }
}

User

package com.loong.test.stream;

/**
 * @Author: loong
 * @Date: 2023-09-22
 */
public class User {
    private Long userId;
    private String userName;
    private Integer age;
    private Integer status;


    public User(Long userId, String userName, Integer age, Integer status) {
        this.userId = userId;
        this.userName = userName;
        this.age = age;
        this.status = status;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", status=" + status +
                '}';
    }
}

**