1、List转化为新的List

//取出某个属性转化为新的集合
List<String> userNameList = list.stream().map(User::getUsername).collect(Collectors.toList());

//转化为其他对象的集合
List<UserVO> userVOList = list.stream().map(item -> new UserVO(item)).collect(Collectors.toList());

//map()中还可以写复杂逻辑
list.stream().map(item -> {
    item.setUsername("xxx");
    item.setEmail("xxx");
    //......
    return item;
}).collect(Collectors.toList());

2、List转Map

• 键值对都是某一个属性

//注意：使用User::getId这种方式取值时，如果集合中的元素，这两个属性有为null的时候，会抛出空指针异常
Map<String, String> map = list.stream().collect(Collectors.toMap(User::getId, User::getUsername));

Map<String, String> map = 
    list.stream().collect(Collectors.toMap(item -> item.getId(), item -> item.getUsername()));

• key为属性，value为对象本身

Map<String, User> map = list.stream().collect(Collectors.toMap(User::getId, item -> item));

3、过滤数据

//简单的过滤规则
List<User> newList = list.stream().filter(item -> StrUtil.isNotBlank(item.getNickname())).collect(Collectors.toList());

//自定义复杂规则
 List<User> newList = list.stream().filter(item ->{
     if (StrUtil.isNotBlank(item.getUsername()) && "xxx".equals(item.getNickname())) {
         return true;
     }
     //。。。。。。
     return false;
 }).collect(Collectors.toList());

4、List统计（求和、最大值、最小值、平均值）

• 求和

//这里是先过滤为空的数据再求和
Integer num = list.stream().filter(item -> item.getSort() != null).mapToInt(User::getSort).sum();

• 最大值

list.stream().mapToDouble(User::getHeight).max()

• 最小值

list.stream().mapToDouble(User::getHeight).min()

• 平均值

list.stream().mapToDouble(User::getHeight).average()

5、将List转换为用逗号隔开的字符串

String result = list.stream().map(String::valueOf).collect(Collectors.joining(","));

6、判断两个集合是否相等

//思路：将需要比较的属性值取出来转化为字符串，让后使用字符串的 equals()方法去比较（或者使用自定义的比较规则去比较，自己扩展）
boolean equals = list.stream().map(item -> Integer.toString(item.getSort()))
                .sorted().collect(Collectors.joining())
                .equals(
                        list1.stream().map(item -> Integer.toString(item.getSort()))
                                .sorted().collect(Collectors.joining())
                );

7、Map格式转换

//模拟数据，id为key，昵称为value
Map<String, String> map = new HashMap<>();
map.put("1", "张三");
map.put("2", "李四");

//转化为，id为key，User对象为value（这里默认User有通过昵称创建的构造方法）
Map<String, User> newMap = map.entrySet().stream().collect(Collectors.toMap(item -> item.getKey(), item -> new User(item.getValue())));

/**
 *  list 转 map
 *  使用Collectors.toMap的时候，如果有可以重复会报错，所以需要加(k1, k2) -> k1
 *  (k1, k2) -> k1 表示，如果有重复的key,则保留第一个，舍弃第二个
 */
Map<Long, UserInfo> userInfoMap = userInfoList.stream().collect(Collectors.toMap(UserInfo::getUserId, userInfo -> userInfo, (k1, k2) -> k1));
userInfoMap.values().forEach(a->System.out.println(a.getUserName()));

8、根据字段去重

 list = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList::new));

9、取交集、并集、差集、去重并集

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("1");
        list1.add("2");
        list1.add("3");
        list1.add("4");
        list1.add("5");

        List<String> list2 = new ArrayList<>();
        list2.add("2");
        list2.add("3");
        list2.add("6");
        list2.add("7");

        // 交集
        List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
        System.out.println("---交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);

        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
        System.out.println("---差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);

        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
        System.out.println("---差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);

        // 并集
        List<String> listAll = list1.parallelStream().collect(toList());
        List<String> listAll2 = list2.parallelStream().collect(toList());
        listAll.addAll(listAll2);
        System.out.println("---并集 listAll---");
        listAll.parallelStream().forEachOrdered(System.out::println);

        // 去重并集
        List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
        System.out.println("---得到去重并集 listAllDistinct---");
        listAllDistinct.parallelStream().forEachOrdered(System.out::println);

    }

10、根据某属性分组

//根据部门分组
Map<Long, List<PerformanceTargetItemEntity>> map = 
	list.stream().collect(Collectors.groupingBy(PerformanceTargetItemEntity::getDeptId));

11、分组后取每组最大值

//分组 然后取每组version最大值（取最大值之后排除已删除的）的那条数据
List<String> permissionList = list.stream()
        .collect(
                Collectors.groupingBy(FirstConfirmTemplateItem::getTag,
                        Collectors.maxBy(Comparator.comparingInt(FirstConfirmTemplateItem::getVersion)))
        ).values().stream().map(Optional::get)
        .filter(item -> !StringUtils.equals(item.getChangeType(), FirstConfirmTemplateChangeTypeEnum.DELETE.getCode()))
        .map(FirstConfirmTemplateItem::getPermissions).collect(Collectors.toList());

12、字段排序

正序

List.stream().sorted(Comparator.comparing(PersEmpHouseholdExcelDto::getId)).collect(Collectors.toList());

倒序

List.stream().sorted(Comparator.comparing(PersEmpHouseholdExcelDto::getId).reversed()).collect(Collectors.toList());

13、找出重复的元素

List<String> list = new ArrayList<>();
//......
List<String> duplicateElements = list.stream() // list 对应的 Stream
    .collect(Collectors.toMap(e -> e, e -> 1, (a, b) -> a + b)) // 获得元素出现频率的 Map，键为元素，值为元素出现的次数
    .entrySet().stream() // 所有 entry 对应的 Stream
    .filter(entry -> entry.getValue() > 1) // 过滤出元素出现次数大于 1 的 entry
    .map(entry -> entry.getKey()) // 获得 entry 的键（重复元素）对应的 Stream
    .collect(Collectors.toList());

System.out.println("list 中重复的元素：" + duplicateElements);

14、遍历List、Map

/**
 * forEach 遍历集合List列表
 */
List<String> userNameList = Arrays.asList("aaa", "bbb", "ccc");
userNameList.forEach(System.out::println);
 
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("a", "123");
hashMap.put("b", "345");
hashMap.put("c", "456");
/**
 *  forEach 遍历集合Map
 */
hashMap.forEach((k, v) -> System.out.println(k + ":\t" + v));

15、findFirst 返回第一个

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
list.stream().findFirst().ifPresent(System.out::println);