Traitement des listes en Java 8 - ajouter des éléments de manière conditionnelle

Question

J'ai le morceau de code suivant :

List<Object> list = new ArrayList<>();
list.addAll(method1());
if(list.isEmpty()) { list.addAll(method2()); }
if(list.isEmpty()) { list.addAll(method3()); }
if(list.isEmpty()) { list.addAll(method4()); }
if(list.isEmpty()) { list.addAll(method5()); }
if(list.isEmpty()) { list.addAll(method6()); }
return list;

Existe-t-il un moyen agréable d'ajouter des éléments de manière conditionnelle, peut-être en utilisant des opérations de flux ? J'aimerais ajouter les éléments de la méthode 2 seulement si la liste est vide, sinon retour et ainsi de suite.

Edit : Il est utile de mentionner que les méthodes contiennent une logique lourde et qu'il faut empêcher leur exécution.

Answer 1

Vous pouvez essayer de vérifier la valeur de retour de addAll . Il retournera true chaque fois que la liste a été modifiée, alors essayez ceci :

List<Object> list = new ArrayList<>();
// ret unused, otherwise it doesn't compile
boolean ret = list.addAll(method1())
    || list.addAll(method2()) 
    || list.addAll(method3())
    || list.addAll(method4())
    || list.addAll(method5())
    || list.addAll(method6());
return list;

En raison de l'évaluation paresseuse, la première addAll L'opération qui a ajouté au moins un élément empêchera le reste d'être appelé. J'aime le fait que "||" exprime assez bien l'intention.

Answer 2

Je voudrais simplement utiliser un flux de fournisseurs et filtrer sur List.isEmpty :

Stream.<Supplier<List<Object>>>of(() -> method1(), 
                                  () -> method2(), 
                                  () -> method3(), 
                                  () -> method4(), 
                                  () -> method5(), 
                                  () -> method6())
    .map(Supplier<List<Object>>::get)
    .filter(l -> !l.isEmpty())
    .findFirst()
    .ifPresent(list::addAll);

return list;

findFirst() évitera les appels inutiles à methodN() lorsque la première liste non vide est retournée par l'une des méthodes.

EDITAR:
Comme indiqué dans les commentaires ci-dessous, si votre list n'est pas initialisé avec autre chose, alors il est logique de retourner directement le résultat du flux :

return  Stream.<Supplier<List<Object>>>of(() -> method1(), 
                                          () -> method2(), 
                                          () -> method3(), 
                                          () -> method4(), 
                                          () -> method5(), 
                                          () -> method6())
    .map(Supplier<List<Object>>::get)
    .filter(l -> !l.isEmpty())
    .findFirst()
    .orElseGet(ArrayList::new);

Answer 3

Une façon de le faire sans se répéter est d'extraire une méthode qui le fait pour vous :

private void addIfEmpty(List<Object> targetList, Supplier<Collection<?>> supplier) {
    if (targetList.isEmpty()) {
        targetList.addAll(supplier.get());
    }
}

Et puis

List<Object> list = new ArrayList<>();
addIfEmpty(list, this::method1);
addIfEmpty(list, this::method2);
addIfEmpty(list, this::method3);
addIfEmpty(list, this::method4);
addIfEmpty(list, this::method5);
addIfEmpty(list, this::method6);
return list;

Ou même utiliser une boucle for :

List<Supplier<Collection<?>>> suppliers = Arrays.asList(this::method1, this::method2, ...);
List<Object> list = new ArrayList<>();
suppliers.forEach(supplier -> this.addIfEmpty(list, supplier));

Maintenant, DRY n'est pas l'aspect le plus important. Si vous pensez que votre code original est plus facile à lire et à comprendre, alors gardez-le ainsi.

Answer 4

Vous pourriez rendre votre code plus agréable en créant la méthode

public void addAllIfEmpty(List<Object> list, Supplier<List<Object>> method){
    if(list.isEmpty()){
        list.addAll(method.get());
    }
}

Ensuite, vous pouvez l'utiliser comme suit (j'ai supposé que vos méthodes ne sont pas des méthodes statiques, si c'est le cas, vous devez les référencer à l'aide de la fonction ClassName::method1 )

List<Object> list = new ArrayList<>();
list.addAll(method1());
addAllIfEmpty(list, this::method2);
addAllIfEmpty(list, this::method3);
addAllIfEmpty(list, this::method4);
addAllIfEmpty(list, this::method5);
addAllIfEmpty(list, this::method6);
return list;

---

Si vous voulez vraiment utiliser un Stream, vous pouvez faire ceci

 Stream.<Supplier<List<Object>>>of(this::method1, this::method2, this::method3, this::method4, this::method5, this::method6)
                .collect(ArrayList::new, this::addAllIfEmpty, ArrayList::addAll);

_{En fonction de la manière dont vos méthodes sont référencées, il peut être préférable d'utiliser une boucle.<br>}

Answer 5

Vous pourriez créer une méthode de ce type :

public static List<Object> lazyVersion(Supplier<List<Object>>... suppliers){
      return Arrays.stream(suppliers)
                .map(Supplier::get)
                .filter(s -> !s.isEmpty()) // or .filter(Predicate.not(List::isEmpty)) as of JDK11
                .findFirst()
                .orElseGet(Collections::emptyList);
}

puis l'appeler comme suit :

lazyVersion(() -> method1(),
            () -> method2(),
            () -> method3(),
            () -> method4(),
            () -> method5(),
            () -> method6());

nom de la méthode à des fins d'illustration uniquement.