Stream流操作集合常见用法

List转为Map<String, List>

一个键对应多个值
key为对象的其中一个值，value为key值对应的所有数据形成的列表

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        list.add(new User("3", "003", "name03"));
        list.add(new User("3", "003", "name03"));
        Map<String, List<User>> map = list
        .stream()
        .collect(Collectors.groupingBy(User::getCode));
        System.out.println(map);
    }

List转Map<String,Object>

一个键对应一个值
key值为对象的一个字段，value为对象

key值不重复

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        Map<String, User> map = list
        .stream()
        .collect(Collectors.toMap(User::getId, Function.identity()));
        System.out.println(map);
    }

注意：
这里的key不能重复，重复会报错

key值重复

如果key值可能会重复，使用以下方式：

保留第一个值

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        list.add(new User("3", "003", "name03"));
        list.add(new User("3", "003", "name003"));
        //如果id重复，保留现有的值
        Map<String, User> map = list
        .stream()
        .collect(Collectors.toMap(User::getId, Function.identity(), 
                                  (existing, replacement) -> existing));
        System.out.println(map);
    }

保留最新的值

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        list.add(new User("3", "003", "name03"));
        list.add(new User("3", "003", "name003"));
        //如果id重复，保留新的值
        Map<String, User> map = list
        .stream()
        .collect(Collectors.toMap(User::getId, Function.identity(),
                                  (existing, replacement) -> replacement));
        System.out.println(map);
    }

List转Map<String,String>

key为对象中的其中一个字段值，value为对象中的另一个字段值。
如：key为id，value为code值。

key值不重复

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        Map<String, String> map = list
        .stream()
        .collect(Collectors.toMap(User::getId, User::getCode));
    }

注意：使用这种方式，如果key值重复会报错

key值重复

保留第一个值

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        list.add(new User("3", "003", "name03"));
        list.add(new User("3", "003", "name003"));
        //如果id重复，保留现有的值
        Map<String, String> map = list
        .stream()
        .collect(Collectors.toMap(User::getId, User::getCode,
                                  (firstVal, lastVal) -> firstVal));
        System.out.println(map);
    }

保留最新的值

    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("1", "001", "name1"));
        list.add(new User("2", "002", "name2"));
        list.add(new User("3", "003", "name3"));
        list.add(new User("3", "003", "name03"));
        list.add(new User("3", "003", "name003"));
        //如果id重复，保留新的值
        Map<String, String> map = list
        .stream()
        .collect(Collectors.toMap(User::getId, User::getCode,
                                  (firstVal, lastVal) -> lastVal));
        System.out.println(map);
    }

去除集合中的重复元素

    /**
     * 去除集合中的重复元素
     */
    private static void distinct() {
        List<String> list = Arrays.asList("a", "b", "a", "c");
        list = list.stream().distinct().collect(Collectors.toList());
        list.forEach(System.out::println);
    }

获取集合中的第一个元素

    /**
     * 获取集合中的第一个元素
     */
    private static void getFirst() {
        List<String> list = Arrays.asList("a", "b", "c");
        String first = list.stream().findFirst().get();
        System.out.println(first);
    }

检查是否存在满足条件的元素

    /**
     * 检查是否存在满足条件的元素
     */
    private static void anyMatch() {
        List<String> list = Arrays.asList("a", "b", "c");
        boolean anyMatch = list.stream().anyMatch(s -> s.equals("a"));
        System.out.println(anyMatch);
    }

检查是否所有元素都满足条件

    /**
     * 检查是否所有元素都满足条件
     */
    private static void allMatch() {
        List<String> list = Arrays.asList("a", "b", "c");
        boolean allMatch = list.stream().allMatch(s -> s.length() == 1);
        System.out.println(allMatch);
    }

检查是否所有元素都不满足条件

    /**
     * 检查是否所有元素都不满足条件
     */
    private static void noneMatch() {
        List<String> list = Arrays.asList("a", "b", "c");
        boolean noneMatch = list.stream().noneMatch(s -> s.length() > 1);
        System.out.println(noneMatch);
    }

排序

对基本类型排序

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 7, 2, 8);
        List<Integer> sortedNumbers = numbers.stream()
            .sorted()
            .collect(Collectors.toList());
        // 输出: [2, 3, 5, 7, 8]
        System.out.println(sortedNumbers); 
    }
}

对自定义对象排序

根据对象的单个字段排序

正序排序

    /**
     * 对单个字段进行排序(正序)
     *
     * @param list 排序后的列表
     */
    private static void sort(List<User> list) {
        List<User> sortList = list
                .stream()
                .sorted(Comparator.comparing(User::getCode))
                .collect(Collectors.toList());
        sortList.forEach(System.out::println);
    }

倒序排序

    /**
     * 对单个字段进行排序(倒序)
     *
     * @param list 排序后的列表
     */
    private static void reverseSort(List<User> list) {
        List<User> sortList = list
                .stream()
                .sorted(Comparator.comparing(User::getCode).reversed())
                .collect(Collectors.toList());
        sortList.forEach(System.out::println);
    }

根据多个字段排序

    /**
     * 按照多字段进行排序
     * 1、先按照code倒序排序
     * 2、再按照name正序排序
     *
     * @param list
     */
    private static void sortMore(List<User> list) {
        List<User> sortList = list
                .stream()
                .sorted(Comparator.comparing(User::getCode).reversed()
                        .thenComparing(User::getName))
                .collect(Collectors.toList());
    }