Comment utiliser collect call dans Java 8?

Permet de dire que nous avons ce ennuyeux morceau de code que nous avons tous eu à utiliser:

ArrayList<Long> ids = new ArrayList<Long>();
for (MyObj obj : myList){
    ids.add(obj.getId());
}

Après le passage à Java 8, mon IDE est de me dire que je peux remplacer ce code avec collect callet il génère automatiquement:

ArrayList<Long> ids = myList.stream().map(MyObj::getId).collect(Collectors.toList());

Cependant, sa me donne cette erreur:

collect(java.util.stream.Collector<? super java.lang.Long,A,R>) in Steam cannot be 
applied to: (java.util.stream.Collector<T>, capture<?>, java.util.List<T>>)

J'ai essayé le casting du paramètre, mais sa me donne pas défini A et Ret l'IDE n'est pas de donner des suggestions.

Je suis curieux de savoir comment pouvez-vous utiliser collect call dans ce scénario, et je ne pouvais pas trouver toutes les informations qui pourraient me guider correctement. Quelqu'un peut jeter une lumière?

source d'informationauteur Alexandru Severin | 2014-11-13

40

Le problème est que Collectionneurs.toListil n'est pas surprenant, renvoie une List<T>. Pas un ArrayList.
```
List<Long> ids = remove.stream()
        .map(MyObj::getId)
        .collect(Collectors.toList());
```
Programme de la interface.

À partir de la documentation:

Renvoie une Collectorqui s'accumule à l'entrée des éléments dans une nouvelle
List. Il y a aucune garantie sur le type, la mutabilité,
serializability, ou le fil de sécurité de la List retourné; si plus
le contrôle de la Liste retournée est nécessaire, l'utilisation
toCollection(Supplier).

C'est moi qui souligne - on ne peut même supposer que le List retourné est mutable, et encore moins qu'elle est d'une classe spécifique. Si vous souhaitez un ArrayList:
```
ArrayList<Long> ids = remove.stream()
        .map(MyObj::getId)
        .collect(Collectors.toCollection(ArrayList::new));
```
A noter également, qu'il est d'usage d'utiliser import static avec Java 8 Stream API afin d'ajouter:
```
import static java.util.stream.Collectors.toCollection;
```
(Je déteste étoilé import staticil ne fait rien, mais de polluer l'espace de noms et d'ajouter de la confusion. Mais sélective import staticsurtout avec Java 8 classes utilitaires, peut réduire considérablement code redondant)

Dans
```
ArrayList<Long> ids = remove.stream()
        .map(MyObj::getId)
        .collect(toCollection(ArrayList::new));
```
2

J'utilise beaucoup de collecteur de blocs où je créer un Tableau vide et le remplir à l'aide d'une boucle donc j'ai décidé que j'avais besoin d'un utilitaire de classe de mes propres pas à écrire les mêmes lignes de nouveau annonce à nouveau, ici, c'est:
```
public class Collections {

    public static <T, O> List<T> collect(Set<O> items, Function<? super O, ? extends T> mapper) {

    return items.stream().map(mapper).collect(Collectors.toCollection(ArrayList::new));
}
```
}

et de l'utiliser comme ceci
```
List<Product> prods = Collections.collect(basket.getOrderItems(), OrderItem::getProduct);
```
ou comme ce
```
List<Long> prods = Collections.collect(basket.getOrderItems(), (item)->item.getProduct().getId());
```
Si cela peut ressembler à de beaucoup plus facile à lire, il semble que les ruisseaux sont un peu plus lent dans ce genre de scénarios, regardez ici

Vous devez vous connecter pour publier un commentaire.