Java 8 lambda（List-＞Map、过滤、类型转换、分组、求和）

多个list取交集

public static List<Element> retainElementList(List<List<Element>> elementLists) {
     
        Optional<List<Element>> result = elementLists.parallelStream()
            .filter(elementList -> elementList != null && ((List) elementList).size() != 0)
            .reduce((a, b) -> {
                a.retainAll(b);
                return a;
        });
        return result.orElse(new ArrayList<>());
    }

List 转Map

    /**
     *  * List -> Map
     *  * 需要注意的是：
     *  * toMap 如果集合对象有重复的key，会报错Duplicate key ....
     *  *  apple1,apple12的id都为1。
     *  *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
     */
    private void listToMap(){
        List<Item> itemList = initList();
        Map<Long,Item> itemMap =  itemList.parallelStream().collect(Collectors.toMap(Item::getId, item -> item,(k1, k2)->k1));
    }

过滤

    /**
     * 从集合中过滤出来符合条件的元素：
     */
    private void filter(){
        List<Item> itemList = initList();
        List<Item> itemFilter =itemList.parallelStream().filter(item -> item.getId()!=null).filter(item -> item.getId()>0).collect(Collectors.toList());
    }

类型转换

    /**
     * 类型转换
     */
    private void typeConversion(){
        List<String> stringList = new ArrayList<>();
        List<Long> longList = stringList.parallelStream().map(Long::valueOf).collect(Collectors.toList());
    }

分组

    /**
     * 分组
     */
    private void groupingBy(){
        List<Item> itemList = initList();
        Map<Long,List<Item>> itemMap = itemList.parallelStream().collect(Collectors.groupingBy(Item::getId));
    }

求和

    /**
     * 属性求和
     */
    private void sum(){
        List<Item> itemList = initList();
        BigDecimal totalBigDecimal =  itemList.parallelStream().map(Item::getBigDecimal).reduce(BigDecimal.ZERO,BigDecimal::add);
        itemList.parallelStream().mapToDouble(Item::getScore).sum();
    }

查找流中最大 最小值

public void maxMin(){
    Optional<Dish> maxDish = Dish.menu.stream().collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)));
    maxDish.ifPresent(System.out::println);

    Optional<Dish> minDish = Dish.menu.stream().collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)));
    minDish.ifPresent(System.out::println);
}

去重

// 根据id去重
public void dd(){
	List<AppColumnsDto> collect = list.stream().collect(
		Collectors.collectingAndThen(Collectors.toCollection(() ->
				new TreeSet<>(Comparator.comparingLong(AppColumnsDto::getId))
	), ArrayList::new));
}

Collectors类的静态工厂方法

工厂方法	返回类型	作用
toList	List<T>	把流中所有项目收集到一个 List
toSet	Set<T>	把流中所有项目收集到一个 Set，删除重复项
toCollection	Collection<T>	把流中所有项目收集到给定的供应源创建的集合menuStream.collect(toCollection(), ArrayList::new)
counting	Long	计算流中元素的个数
sumInt	Integer	对流中项目的一个整数属性求和
averagingInt	Double	计算流中项目 Integer 属性的平均值
summarizingInt	IntSummaryStatistics	收集关于流中项目 Integer 属性的统计值，例如最大、最小、 总和与平均值
joining	String	连接对流中每个项目调用 toString 方法所生成的字符串collect(joining(", "))
maxBy	Optional<T>	一个包裹了流中按照给定比较器选出的最大元素的 Optional， 或如果流为空则为 Optional.empty()
minBy	Optional<T>	一个包裹了流中按照给定比较器选出的最小元素的 Optional， 或如果流为空则为 Optional.empty()
reducing	归约操作产生的类型	从一个作为累加器的初始值开始，利用 BinaryOperator 与流 中的元素逐个结合，从而将流归约为单个值累加int totalCalories = menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));
collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果应用转换函数int howManyDishes = menuStream.collect(collectingAndThen(toList(), List::size))
groupingBy	Map<K, List<T>>	根据项目的一个属性的值对流中的项目作问组，并将属性值作 为结果 Map 的键
partitioningBy	Map<Boolean,List<T>>	根据对流中每个项目应用谓词的结果来对项目进行分区