Java8 Collectors.toMap()和Collectors.groupingBy()输出乱序

1. Collectors.toMap() 输出乱序

1.1 场景

想按创建时间降序列表展示订单信息，但最终返回给前端的数据和idList顺序不一致，乱序输出。
Debug发现有段代码，根据idList从数据库中查询出orderList，输出一个以订单编号为key，订单内容为value的Map，该Map输出内容是乱序的。

......
//根据订单idList查询订单列表
List<Order> orderList = orderDao.listOrderByIds(idList);  
//输出以订单id为key的Map
Map<Long, Order> orderMap = orders.stream().collect(Collectors.toMap(Order::getId, order -> order, (k1, k2) -> k1));
......

查看Collectors.toMap()源码发现其输出的Map是HashMap，而HashMap不是按顺序存的。

1.2 Collectors.toMap()

Collectors.toMap()有三个参数，以Collectors.toMap(Order::getId, a -> a, (k1, k2) -> k1)为例，第一个参数Order::getId为Map的key，第二个参数order -> order为value，第三个参数(k1, k2) -> k1表示出现相同的key时，取旧key值对应的value值。

点进Collectors.toMap()源码，可以看到，输出的Map是HashMap。

public static <T, K, U>
    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper,
                                    BinaryOperator<U> mergeFunction) {
        return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
    }

而HashMap输出是乱序的。

1.3 HashMap

HashMap输出乱序，和它存数据的方式有关。
HashMap使用哈希表来存储，为了解决Hash冲突使用的是链地址法。在每个数组元素上都一个链表结构，当数据被Hash后，得到被扰乱的hash值，然后通过位与运算获取数组下标，最后把数据放在该数组下标链表上。
遍历输出时，是遍历的tab[]数组，而数组经过计算hash值，存进的数据和最初的List顺序可能不一致了。

	final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //1
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            ......
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }	

计算hash值。

	static final int hash(Object key) {
        int h;
        //2
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

HashMap遍历Node<K,V>[] tab输出。

	@Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
            	//3
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e.key, e.value);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

为什么是乱序的可参考该文章：HashMap源码分析 —— HashMap为什么是无序的？

如果想要输出有序，推荐使用LinkedHashMap。

1.4 LinkedHashMap

LinkedHashMap除实现HashMap，还维护了一个双向链表。LinkedHashMap为每个Entry添加了前驱和后继，每次向linkedHashMap插入键值对，除了将其插入到哈希表的对应位置之外，还要将其插入到双向循环链表的尾部。
在forEach遍历时，HashMap遍历的是tab[]数组，LinkedHashMap遍历的是双向链表，从head开始，即最初的List顺序。

	public void forEach(BiConsumer<? super K, ? super V> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        //4
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
            action.accept(e.key, e.value);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }

为什么有序参考这篇文章：LinkedHashMap 如何保证插入顺序的(jdk8)

1.5 解决方案

为保证输出有序，选择LinkedHashMap，具体修改方案如下：

LinkedHashMap<Long, Order> orderMap = orders.stream().collect(Collectors.toMap(Order::getId, order -> order, (k1, k2) -> k1,LinkedHashMap::new));

2. Collectors.groupingBy() 输出乱序

2.1 场景

想要以id分组输出Map，结果输出是乱序的。

Map<Long, List<OrderVO>> map;
map = list.stream().collect(Collectors.groupingBy(OrderVO::getId));

其原因和Collectors.toMap()类似，查看源码可知Collectors.groupingBy()输出为HashMap。

	public static <T, K, A, D>
    	Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream) {
        return groupingBy(classifier, HashMap::new, downstream);
    }

2.2 解决方案

选择以LinkedHashMap输出。

map = list.stream().collect(Collectors.groupingBy(OrderVO::getId, LinkedHashMap::new, Collectors.toList()));