Java8 Stream method

Comparator

• Comparator.comparing(Function<T, U>)

// java.util.Collections#sort(java.util.List<T>, java.util.Comparator<? super T>)
public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}
// e.g.
List<Apple> apples = new ArrayList<>();
Collections.sort(apples, new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight() - o2.getWeight();
    }
});

// e.g.
apples.sort(Comparator.comparing(Apple::getWeight));
Collections.sort(employees, (o1, o2) -> o1.getAge() - o2.getAge());

Collectors

• Collectors.toList()
• Collectors.maxBy(Comparator<? super T> comparator)
• Collectors.summingInt(ToIntFunction<? super T> mapper), averagingInt
• Collectors.summarizingInt(ToIntFunction<? super T> mapper)
• Collectors.joining(CharSequence delimiter)
• 广义的规约 Collectors.reducing(U identity,Function mapper,BinaryOperator op)

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

Comparator<OrderDO> comparator = Comparator.comparingInt(OrderDO::getId);
Optional<OrderDO> maxId = list.stream().collect(Collectors.maxBy(comparator));
// 字符串连接
String names = list.stream().map(OrderDO::getName).collect(Collectors.joining(","));
// 汇总
Integer collect = list.stream().collect(summingInt(OrderDO::getId));
Integer collect2 = list.stream().mapToInt(OrderDO::getId).sum();
Integer collect3 = list.stream().collect(reducing(0, OrderDO::getId, (i, j) -> i + j));
Integer collect4 = list.stream().map(OrderDO::getId).reduce(0, (i, j) -> i + j);

groupBy

• Map<K, List<T>> Collectors.groupingBy(Function classifier)
• Function 是分类函数，分组的结果是一个Map
• 键：分类值，值：包含分类值的列表
• 操作分组元素
  • Collectors.groupingBy(Function classifier, Collector downstream)
  • 过滤操作 Collectors.filtering(Predicate predicate, Collector downstream)
  • 映射操作 Collectors.mapping(Function mapper, Collector downstream)
• 多级分组
  • 把内层groupingBy传递给外层groupingBy
  • n级分组就会得到一个代表n级树形结构的n级Map

Map<String, List<OrderDO>> maps = list.stream().collect(groupingBy(OrderDO::getType));
Map<Boolean, List<OrderDO>> collect = list.stream().collect(groupingBy(orderDO -> orderDO.getId() > 20));
// 对分组中的元素进行操作
Map<String, List<OrderDO>> collect1 = list.stream().collect(groupingBy(OrderDO::getType, filtering(orderDO -> orderDO.getId() > 20, toList())));
Map<String, List<Integer>> collect2 = list.stream().collect(groupingBy(OrderDO::getType, mapping(OrderDO::getId, toList())));
// 疑问点
Map<String, Set<String>> collect = goodsList.stream().collect(
      groupingBy(Goods::getName,
            flatMapping(goods -> maps.get(goods.getName()).stream(), Collectors.toSet())));

Map<String, Map<String, List<OrderDO>>> collect2 = orderList.stream().collect(
                groupingBy(OrderDO::getType,   // 一级分类函数
                        groupingBy(OrderDO::getName))); // 二级分类函数
// 分组收集
Map<String, Integer> collect1 = orderList.stream().collect(
                groupingBy(OrderDO::getType, summingInt(OrderDO::getId)));

partitioningBy

• 分区是分组的特殊情况，由一个谓词作为分类函数，分区函数返回一个布尔值
• Map 的键类型是 Boolean, 最多有两组：true / false

Map<Boolean, List<OrderDO>> map = orderList.stream().collect(partitioningBy(orderDO -> orderDO.getId() > 20));
 List<OrderDO> result = map.get(true);

source code

• interface Collector
• java.util.stream.Collector.Characteristics, IDENTITY_FINISH 恒等函数
• Stream.collect(Collector collector);
• 重载方法Stream.collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner);

ArrayList<Object> list = orders.stream().collect(ArrayList::new, List::add, List::addAll);

Collection API

• 不可变集合
• Arrays.asList(T... a) 固定大小的列表，若有修改等 java.lang.UnsupportedOperationException
• Map.of(K k1, V v1)
• Map.ofEntries(entry(K, V));
• Map.forEach(BiConsumer<? super K, ? super V> action)

Map 计算模式

• Map.computeIfAbsent(K key, Function<K, V>) 不存在就添加，存在不处理
• Map.computeIfPresent(K key, BiFunction<K, V, V>) 存在就覆盖
• Map.compute(K key, BiFunction<K, V, V>) 不管是否存在都添加