Java8，Lambda：在分组列表中排序并将所有组合并到一个列表中

Question

根据以下答案：https://stackoverflow.com/a/30202075/8760211

如何按stud\u id对每个组进行排序，然后返回一个包含所有学生的列表，作为按stud\u位置分组的结果，然后按stud\u id排序）？

将此作为现有Lambda表达式的扩展将非常好：

Map<String, List<Student>> studlistGrouped =
    studlist.stream().collect(Collectors.groupingBy(w -> w.stud_location));

我需要根据原始列表中元素的顺序进行分组。

First group: "New York"
Second group: "California"
Third group: "Los Angeles"

1726, "John", "New York"
4321, "Max", "California"
2234, "Andrew", "Los Angeles"
5223, "Michael", "New York"
7765, "Sam", "California"
3442, "Mark", "New York"

结果如下所示：

List<Student> groupedAndSorted = ....

    1726, "John", "New York"
    3442, "Mark", "New York"
    5223, "Michael", "New York"
    4321, "Max", "California"
    7765, "Sam", "California"
    2234, "Andrew", "Los Angeles"

我尝试了以下方法：

studlistGrouped.entrySet().stream().sorted(Comparator.compar‌​ing(Map.Entry::getVa‌​lue))

但这行不通。

Answer 1

由于结果应该是一个列表，所以您不需要分组，而只需排序（根据定义的规则更改顺序）。主要的障碍是，您希望在原始列表中第一次遇到位置后对其进行排序。

直接的方法是首先修复此位置顺序，然后进行单个排序操作：

Map<String,Integer> locationOrder = studlist.stream()
    .collect(HashMap::new,
             (m,s)->m.putIfAbsent(s.stud_location, m.size()),
             (m1,m2)->m2.keySet().forEach(l->m1.putIfAbsent(l, m1.size())));

studlist.sort(Comparator.comparingInt((Student s) -> locationOrder.get(s.stud_location))
                        .thenComparing(s -> s.stud_id));

如果您不能或不想修改原始列表，只需使用副本即可：

List<Student> result = new ArrayList<>(studlist);
result.sort(Comparator.comparingInt((Student s) -> locationOrder.get(s.stud_location))
                      .thenComparing(s -> s.stud_id));

也可以通过分组操作来解决此问题，但这并不容易：

List<Student> result = studlist.stream()
    .collect(Collectors.collectingAndThen(
                Collectors.groupingBy(s -> s.stud_location,
                                      LinkedHashMap::new, Collectors.toList()),
                m -> m.values().stream()
                      .flatMap(l -> l.stream().sorted(Comparator.comparing(s->s.stud_id)))
                      .collect(Collectors.toList())));

请注意，您必须收集到LinkedHashMap中以确保保留组的顺序。

Answer 2

如果我没说错的话，你需要一份清单

//first, use your function to group students
Map<String, List<Student>> studlistGrouped = students.stream()
        .collect(Collectors.groupingBy(Student::getLocation, Collectors.toList()));

//then sort groups by minimum id in each of them
List<Student> sorted = studlistGrouped.entrySet().stream()
        .sorted(Comparator.comparing(e -> e.getValue().stream().map(Student::getId).min(Comparator.naturalOrder()).orElse(0)))
        //and also sort each group before collecting them in one list
        .flatMap(e -> e.getValue().stream().sorted(Comparator.comparing(Student::getId))).collect(Collectors.toList());

这将产生以下结果：

Student{id='1726', name='John', location='New York'}
Student{id='3442', name='Mark', location='New York'}
Student{id='5223', name='Michael', location='New York'}
Student{id='2234', name='Andrew', location='Los Angeles'}
Student{id='4321', name='Max', location='California'}
Student{id='7765', name='Sam', location='California'}

也许这可以做得更优雅些，欢迎提出建议

编辑：在撰写此答案时，在OPs问题中没有提到根据原始列表中元素的顺序进行分组。所以我的假设是根据ID对列表和组进行排序。有关基于原始列表中顺序的解决方案，请参见其他答案，例如Holgers one

Answer 3

不是100%清楚您是否需要Map

导入：

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

检索地图

Map<String, List<Student>> resultSet = studlist.stream()
      .collect(groupingBy(Student::getLocation,
             mapping(Function.identity(),
                  collectingAndThen(toList(),
                      e -> e.stream().sorted(Comparator.comparingInt(Student::getId))
                                            .collect(toList())))));

另一方面，如果您只想检索按给定属性排序的学生对象列表，那么执行分组方式、排序方式、收集方式，并以某种方式将地图值减少到单个列表中，将是一种资源浪费。而只是在列表中对学生对象进行排序，提供一个排序键，即。

studlist.sort(Comparator.comparingInt(Student::getId));

或

studlist.sort(Comparator.comparing(Student::getLocation));

或者，根据您是否希望按多个属性排序，您可以执行类似于shmosel的回答的操作。