Java 8 ne maintient pas l'ordre lors du regroupement

Je m à l'aide de Java 8 pour le regroupement des données. Mais les résultats obtenus ne sont pas dans l'ordre formé.

Map<GroupingKey, List<Object>> groupedResult = null;
if (!CollectionUtils.isEmpty(groupByColumns)) {
Map<String, Object> mapArr[] = new LinkedHashMap[mapList.size()];
if (!CollectionUtils.isEmpty(mapList)) {
int count = 0;
for (LinkedHashMap<String, Object> map : mapList) {
mapArr[count++] = map;
}
}
Stream<Map<String, Object>> people = Stream.of(mapArr);
groupedResult = people
.collect(Collectors.groupingBy(p -> new GroupingKey(p, groupByColumns), Collectors.mapping((Map<String, Object> p) -> p, toList())));
public static class GroupingKey 
public GroupingKey(Map<String, Object> map, List<String> cols) {
keys = new ArrayList<>();
for (String col : cols) {
keys.add(map.get(col));
}
}
//Add appropriate isEqual() ... you IDE should generate this
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final GroupingKey other = (GroupingKey) obj;
if (!Objects.equals(this.keys, other.keys)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int hash = 7;
hash = 37 * hash + Objects.hashCode(this.keys);
return hash;
}
@Override
public String toString() {
return keys + "";
}
public ArrayList<Object> getKeys() {
return keys;
}
public void setKeys(ArrayList<Object> keys) {
this.keys = keys;
}
}

Ici, je suis avec ma classe groupingKey par lequel je m dynamiquement en passant de ux. Comment pouvez obtenir ce groupByColumns dans triés forme?

source d'informationauteur shreya

  1. 32

    Pas le maintien de l'ordre est une propriété de la Map qui stocke le résultat. Si vous avez besoin d'un Map comportement, vous devez la demande d'un particulier Map de la mise en œuvre. E. g. LinkedHashMap maintient l'ordre d'insertion:

    groupedResult = people.collect(Collectors.groupingBy(
p -> new GroupingKey(p, groupByColumns),
LinkedHashMap::new,
Collectors.mapping((Map<String, Object> p) -> p, toList())));

    Par le façon, il n'y a aucune raison pour copier le contenu de mapList dans un tableau avant de créer le Stream. Il vous suffit d'appeler mapList.stream() de se faire une bonne Stream.

    De plus, Collectors.mapping((Map<String, Object> p) -> p, toList()) est obsolète. p->p est une cartographie de l'identité, donc il n'y a pas de raison de la demande de mapping à tous:

    groupedResult = mapList.stream().collect(Collectors.groupingBy(
p -> new GroupingKey(p, groupByColumns), LinkedHashMap::new, toList()));

    Mais même les GroupingKey est obsolète. Essentiellement, il enroule une List de valeurs, de sorte que vous pouvez simplement utiliser un List clé dans la première place. Lists de mettre en œuvre hashCode et equals de manière appropriée (mais vous ne doit pas modifier ces clés Lists par la suite).

    Map<List<Object>, List<Object>> groupedResult=
mapList.stream().collect(Collectors.groupingBy(
p -> groupByColumns.stream().map(p::get).collect(toList()),
LinkedHashMap::new, toList()));
  2. 0

    @Holger la grande réponse. Je poste ceci pour aider ceux qui veulent garder l'ordre, après le regroupement ainsi que la modification de la cartographie.

    Nous pouvons simplifier et supposons que nous avons une liste de personnes (int age, String nom, String adresss...etc) et nous voulons les noms regroupés par âge tout en gardant les âges dans l'ordre:

    final LinkedHashMap<Integer, List<String> map = myList
.stream()
.sorted(Comparator.comparing(p -> p.getAge())) //sort list by ages
.collect(Collectors.groupingBy(p -> p.getAge()),
LinkedHashMap::new, //keep the order
Collectors.mapping(p -> p.getName(), //map name
Collectors.toList())));