Dtyjlui

I would simply use a stream of suppliers and filter on 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() will prevent unnecessary calls to methodN() when the first non-empty list is returned by one of the methods.

EDIT:

As remarked in comments below, if your list object is not initialized with anything else, then it makes sense to just return the result of the stream directly:

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);

You could try to check the return value of addAll. It will return true whenever the list has been modified, so try this:

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;

Because of lazy evaluation, the first addAll operation that added at least one element will prevent the rest from bein called. I like the fact that "||" expresses the intent quite well.

A way of doing it without repeating yourself is to extract a method doing it for you:

private void addIfEmpty(List<Object> targetList, Supplier<Collection<?>> supplier) {

    if (targetList.isEmpty()) {

        targetList.addAll(supplier.get());

    }

}

And then

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;

Or even use a for loop:

List<Supplier<Collection<?>>> suppliers = Arrays.asList(this::method1, this::method2, ...);

List<Object> list = new ArrayList<>();

suppliers.forEach(supplier -> this.addIfEmpty(list, supplier));

Now DRY is not the most important aspect. If you think your original code is easier to read and understand, then keep it like that.

You could create a method as such:

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);

}

and then call it as follows:

lazyVersion(() -> method1(),

            () -> method2(),

            () -> method3(),

            () -> method4(),

            () -> method5(),

            () -> method6());

method name for illustration purposes only.

You could make your code nicer by creating the method

public void addAllIfEmpty(List<Object> list, Supplier<List<Object>> method){

    if(list.isEmpty()){

        list.addAll(method.get());

    }

}

Then you can use it like this (I assumed your methods are not static methods, if they are you need to reference them using 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;

If you really want to use a Stream, you could do this

 Stream.<Supplier<List<Object>>>of(this::method1, this::method2, this::method3, this::method4, this::method5, this::method6)

                .collect(ArrayList::new, this::addAllIfEmpty, ArrayList::addAll);

_{IMO it makes it more complicated, depending on how your methods are referenced, it might be better to use a loop}