Comment faire pour convertir une Liste<V> Map<K<V>>, avec Java 8 ruisseaux et personnalisé de la Liste et la Carte des fournisseurs?

Il est facile de convertir List<V> en Map<K, List<V>>. Par exemple:

public Map<Integer, List<String>> getMap(List<String> strings) {
   return
      strings.stream()
             .collect(Collectors.groupingBy(String::length));
}

Mais je veux le faire avec mon propre List et Map fournisseurs.

Je suis venu avec cette:

public Map<Integer, List<String>> getMap(List<String> strings) {
   return strings.stream()
       .collect(Collectors.toMap(
             String::length,
             item -> {List<String> list = new ArrayList<>(); list.add(item); return list;},
             (list1, list2) -> {list1.addAll(list2); return list1;},
             HashMap::new));
}

Question: Est-il plus facile, moins verbeux, ou de manière plus efficace de le faire? Par exemple, quelque chose comme ceci (qui ne fonctionne pas):

return strings.stream()
      .collect(Collectors.toMap(
            String::length,
            ArrayList::new,                    
            HashMap::new));

Et si j'ai seulement besoin de définir la List fournisseur, mais pas le Map fournisseur?

Il y a un groupingBy la surcharge de prendre un fournisseur de carte.
Il y a trois arg recueillir méthode sur le cours d'eau qui pourraient vous intéresser

OriginalL'auteur MarcG | 2016-11-23

22

Vous pourriez avoir ce qui suit:
```
public Map<Integer, List<String>> getMap(List<String> strings) {
    return strings.stream().collect(
      Collectors.groupingBy(String::length, HashMap::new, Collectors.toCollection(ArrayList::new))
    );
}
```
Le collecteur groupingBy(classificateur, mapFactory, en aval) peut être utilisé pour spécifier le type de carte est voulu, en passant par un fournisseur de la carte pour le mapFactory. Puis, en aval du collecteur, qui est utilisé pour recueillir des éléments regroupés sur la même touche, est toCollection(collectionFactory), ce qui lui permet de recueillir dans une collection obtenue à partir de la donnée du fournisseur.

Cela permet de s'assurer que la carte retournée est un HashMap et que les listes, chaque valeur, sont ArrayList. Notez que si vous souhaitez retourner des implémentations spécifiques de la map et de collection, alors vous avez probablement envie de la méthode pour le retour de ces types spécifiques, de sorte que vous pouvez utiliser leurs propriétés.

Si vous ne souhaitez spécifier un fournisseur de collection, et de garder groupingBy de carte par défaut, vous pouvez simplement omettre le fournisseur dans le code ci-dessus et utilisez le deux arguments de surcharge:
```
public Map<Integer, List<String>> getMap(List<String> strings) {
    return strings.stream().collect(
      Collectors.groupingBy(String::length, Collectors.toCollection(ArrayList::new))
    );
}
```
Comme une note, vous pourriez avoir une méthode générique pour que:
```
public <K, V, C extends Collection<V>, M extends Map<K, C>> M getMap(List<V> list,
        Function<? super V, ? extends K> classifier, Supplier<M> mapSupplier, Supplier<C> collectionSupplier) {
    return list.stream().collect(
        Collectors.groupingBy(classifier, mapSupplier, Collectors.toCollection(collectionSupplier))
    );
}
```
L'avantage avec cette déclaration, c'est que vous pouvez maintenant l'utiliser pour HashMap de ArrayLists comme résultat, ou LinkedHashMap de LinkedListss, si l'appelant souhaite:
```
HashMap<Integer, ArrayList<String>> m = getMap(Arrays.asList("foo", "bar", "toto"),
        String::length, HashMap::new, ArrayList::new);
LinkedHashMap<Integer, LinkedList<String>> m2 = getMap(Arrays.asList("foo", "bar", "toto"),
        String::length, LinkedHashMap::new, LinkedList::new);
```
mais, à ce stade, il peut être plus simple d'utiliser directement les groupingBy dans le code...

C'est parfait! Toutes les solutions ont travaillé pour moi.

OriginalL'auteur Tunaki

J'ai eu une situation similaire. Je l'ai résolu comme:

Map<String, List<Object>> map = stringList.stream().collect(Collectors.toMap(str -> str, str -> populateList(str)));

Et populateList() est:

private List<Object> populateList(final String str) {
    ...
    ....
    List<Object> list = //dao.get(str);
    return list;
}

OriginalL'auteur Arvind SJ

Vous devez vous connecter pour publier un commentaire.