web-dev-qa-db-fra.com

Utilisation de Java8 Streams pour créer une liste d'objets provenant d'un autre

J'ai les codes Java6 et Java8 suivants:

List<ObjectType1> lst1 = // a list of ObjectType1 objects
List<ObjectType2> lst2 = // a list of ObjectType1 objects, same size of lst1

List<ObjectType3> lst3 = new ArrayLis<ObjectType3>(lst1.size());
for(int i=0; i < lst1.size(); i++){
  lst3.add(new ObjectType3(lst1.get(i).getAVal(), lst2.get(i).getAnotherVal()));
}

Existe-t-il un moyen dans Java8 de traiter le précédent de manière plus concise en utilisant Lambda?

javalambdajava-8java-stream
16
mat_boy

Un flux est lié à une collection ou à une collection donnée, vous ne pouvez donc pas "itérer" deux collections en parallèle.

Une solution de contournement consisterait à créer un flux d'index, mais cela n'améliorera pas nécessairement la boucle for. La version du flux pourrait ressembler à:

List<ObjectType3> lst3 = IntStream.range(0, lst1.size())
         .mapToObj(i -> new ObjectType3(lst1.get(i).getAVal(), lst2.get(i).getAnotherVal()))
         .collect(toList());
27
assylias

Vous pouvez créer une méthode qui transforme deux collections en une nouvelle, comme ceci:

public <T, U, R> Collection<R> singleCollectionOf(final Collection<T> collectionA, final Collection<U> collectionB, final Supplier<Collection<R>> supplier, final BiFunction<T, U, R> mapper) {
    if (Objects.requireNonNull(collectionA).size() != Objects.requireNonNull(collectionB).size()) {
        throw new IllegalArgumentException();
    }
    Objects.requireNonNull(supplier);
    Objects.requireNonNull(mapper);
    Iterator<T> iteratorA = collectionA.iterator();
    Iterator<U> iteratorB = collectionB.iterator();
    Collection<R> returnCollection = supplier.get();
    while (iteratorA.hasNext() && iteratorB.hasNext()) {
        returnCollection.add(mapper.apply(iteratorA.next(), iteratorB.next()));
    }
    return returnCollection;
}

La partie importante ici est qu'il mappera les iteratorA.next() et iteratorB.next() obtenus dans un nouvel objet.

Cela s'appelle comme ça:

List<Integer> list1 = IntStream.range(0, 10).boxed().collect(Collectors.toList());
List<Integer> list2 = IntStream.range(0, 10).map(n -> n * n + 1).boxed().collect(Collectors.toList());
singleCollectionOf(list1, list2, ArrayList::new, Pair::new).stream().forEach(System.out::println);

Dans votre exemple, ce serait:

List<ObjectType3> lst3 = singleCollectionOf(lst1, lst2, ArrayList::new, ObjectType3::new);

Où par exemple Pair::new est un raccourci pour lamdda (t, u) -> new Pair(t, u). 

5
skiwi

Je n'ai pas trouvé le moyen de mettre à jour un flux à un autre, cependant, j'ai accompli un exploit similaire en utilisant une carte. :)

    Map<Integer, String> result = new HashMap<>();
    for(int index = 100; index > 0; index--){
        result.put(index, String.valueOf(index));
    }
    result.keySet().stream()
            .filter(key -> key%3 == 0)
            .sorted()
            .forEach(key -> result.put(key, "Fizz"));

    result.keySet().stream()
            .filter(key -> key%5 == 0)
            .sorted()
            .forEach(key -> result.put(key, "Buzz"));

    result.keySet().stream()
            .filter(key -> key%3 == 0 && key%5 == 0)
            .sorted()
            .forEach(key -> result.put(key, "FizzBuzz"));

    result.keySet().stream().forEach(key -> System.out.println(result.get(key)));
0
Ryan Griffin