如何在保持顺序的同时将 List<P> 中的元素分组到 Map<K, List<V>>？

Question

我有一个来自 Google Places API 的 Google PlaceSummary 对象列表。我想按他们的 Google Place ID 收集和分组它们，但也保留元素的顺序。我认为可行的是：

Map<String, List<PlaceSummary>> placesGroupedByPlaceId =
            places.stream()
                  .collect(Collectors.groupingBy(
                          PlaceSummary::getPlaceId,
                          LinkedHashMap::new,
                          Collectors.mapping(PlaceSummary::getPlaceId, toList())
                  ));

但它甚至不会编译。看起来应该根据Java API documentation on Collectors.

以前我有这个代码：

    Map<String, List<PlaceSummary>> placesGroupedByPlaceId = places.stream()
            .collect(Collectors.groupingBy(PlaceSummary::getPlaceId));

但是，Streams API 上的标准 .collect() 不保留后续 HashMap 中的元素顺序（显然，因为 HashMaps 是无序的）。我希望输出是LinkedHashMap，以便地图按每个桶的插入顺序排序。

但是，我建议的解决方案无法编译。首先，它不能识别PlaceSummary::getPlaceId，因为它说它不是一个函数——尽管我知道它是。其次，它说我不能将LinkedHashMap<Object, Object> 转换为 M。M 应该是一个通用集合，所以它应该被接受。

如何使用 Java Stream API 将 List 转换为 LinkedHashMap？有没有简洁的方法来做到这一点？如果太难理解，我可能会求助于 Java 8 之前的老式方法。

我注意到有 another Stack Overflow answer on converting List to LinkedHashMap，但这没有我想要的解决方案，因为我需要收集“这个”我专门迭代的对象。

Answer 1

如果您需要在维护订单的同时进行分组并应用功能（减少），也许我会使用类似的东西。

final Map<Integer,Long>map=stream.collect(Collectors.groupingBy(function
   ,LinkedHashMap::new
   ,Collectors.collectingAndThen(Collectors.counting(),Function.identity()))
 )

Answer 2

/**
 * I have written this code more generic, if you want then you can group based on any * 
 * instance variable , id, name etc via passing method reference.
**/

class Student {
    private int id;
    private String name;
    public Student(int id, String name) {this.id = id;this.name = name;}
    /**
     * @return the id
     */
    public int getId() {return id;}
    /**
     * @param id
     *            the id to set
     */
    public void setId(int id) {this.id = id;}
    /**
     * @return the name
     */
    public String getName() {return name;}
    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {this.name = name;}
}

public class StudentMain {

    public static void main(String[] args) {

        List<Student> list = new ArrayList<>();
        list.add(new Student(1, "Amit"));
        list.add(new Student(2, "Sumit"));
        list.add(new Student(1, "Ram"));
        list.add(new Student(2, "Shyam"));
        list.add(new Student(3, "Amit"));
        list.add(new Student(4, "Pankaj"));

        Map<?, List<Student>> studentById = groupByStudentId(list,
                Student::getId);
        System.out.println(studentById);

       Map<?, List<Student>> studentByName = groupByStudentId(list,
                Student::getName);
        System.out.println(studentByName);

    }

    private static <K, V> Map<?, List<V>> groupByStudentId(List<V> list,
            Function<V, K> keyFunction) {
        return list.stream().collect(
                Collectors.groupingBy(keyFunction, HashMap::new,
                        Collectors.toList()));
    }
}

Answer 3

你真的很接近你想要的：

Map<String, List<PlaceSummary>> placesGroupedByPlaceId =
            places.stream()
                  .collect(Collectors.groupingBy(
                          PlaceSummary::getPlaceId,
                          LinkedHashMap::new,
                          Collectors.mapping(Function.identity(), Collectors.toList())
                  ));

在Collectors.mapping 方法中，您需要提供PlaceSummary 实例而不是地点ID。在上面的代码中，我使用了Function.identity()：这个收集器用于构建值，因此我们需要累积这些位置本身（而不是它们的 ID）。

注意可以直接写Collectors.toList()而不是Collectors.mapping(Function.identity(), Collectors.toList())。

到目前为止，您的代码无法编译，因为它实际上是在创建 Map<String, List<String>>：您正在为每个 ID 累积 ID（这很奇怪）。

---

你可以把它写成一个通用方法：

private static <K, V> Map<K, List<V>> groupByOrdered(List<V> list, Function<V, K> keyFunction) {
    return list.stream()
                .collect(Collectors.groupingBy(
                    keyFunction,
                    LinkedHashMap::new,
                    Collectors.toList()
                ));
}

并像这样使用它：

Map<String, List<PlaceSummary>> placesGroupedById = groupByOrdered(places, PlaceSummary::getPlaceId);

Answer 4

我想你对最终的收集器有点困惑。它仅表示每个映射值中需要包含的内容。不需要第二个 mapping 收集器，因为您只需要原始对象的列表。

    Map<String, List<PlaceSummary>> placesGroupedByPlaceId =
          places.stream()
                .collect(Collectors.groupingBy(PlaceSummary::getPlaceId,
                                               LinkedHashMap::new,
                                               Collectors.toList()));