RxJava - extraire chaque élément de la liste

Voici une petite autonome exemple

public class Example {

    public static class Item {
        int id;
    }

    public static void main(String[] args) {
        getIds()
                .flatMapIterable(ids -> ids) //Converts your list of ids into an Observable which emits every item in the list
                .flatMap(Example::getItemObservable) //Calls the method which returns a new Observable<Item>
                .subscribe(item -> System.out.println("item: " + item.id));
    }

    //Simple representation of getting your ids.
    //Replace the content of this method with yours
    private static Observable<List<Integer>> getIds() {
        return Observable.just(Arrays.<Integer>asList(1, 2, 3));
    }

    //Replace the content of this method with yours
    private static Observable<Item> getItemObservable(Integer id) {
        Item item = new Item();
        item.id = id;
        return Observable.just(item);
    }
}

Veuillez noter que Observable.just(Arrays.<Integer>asList(1, 2, 3)) est une représentation simple de Observable<ArrayList<Long>> de votre question. Vous pouvez le remplacer par votre propre Observable dans votre code.

Cela devrait vous donner la base de ce que vous avez besoin.

p/s : Utiliser flatMapIterable méthode pour ce cas, car elle appartient à Iterable comme ci-dessous expliquant:

/**
 * Implementing this interface allows an object to be the target of
 * the "for-each loop" statement. See
 * <strong>
 * <a href="{@docRoot}openjdk-redirect.html?v=8&path=/technotes/guides /language/foreach.html">For-each Loop</a>
 * </strong>
 *
 * @param <T> the type of elements returned by the iterator
 *
 * @since 1.5
 * @jls 14.14.2 The enhanced for statement
  */
 public interface Iterable<T>

Utiliser un Transformateur qui modifie la source Observables, l'appel d'une flatMap sur elle avec une fonction. Vous pouvez considérer cela comme un procédé en 2 étapes:

1. La fonction prend chaque émis élément (un Iterable<T>) et re-émet comme un Observable<T>
2. flatMap prend chacun de ces émise Observable<T> objets un les fusionne en un seul Observable<T>

Le Transformateur ressemble à ceci:

public class FlattenTransform<T> implements Observable.Transformer<Iterable<T>, T> {
    @Override
    public Observable<? extends T> call(Observable<? extends Iterable<T>> source) {
        return source.flatMap(new Func1<Iterable<T>, Observable<T>>() {
            @Override
            public Observable<T> call(Iterable<T> values) {
                return Observable.from(values);
            }
        });
    }
}

Une fois que vous avez créé votre Transformateur, vous pouvez utiliser compose pour appliquer la transformation de la source de l'observable:

public class Example {

    private static final ArrayList<Long> sourceList = new ArrayList<>(Arrays.asList(new Long[] {1L,2L,3L}));
    private static final Observable<ArrayList<Long>> listObservable = Observable.just(sourceList);
    private static final FlattenTransform<Long> flattenList = new FlattenTransform<Long>();

    public static void main(String[] args) {
        listObservable.compose(flattenList).subscribe(printItem);
    }

    private static Action1<Long> printItem = new Action1<Long>() {
        @Override
        public void call(Long item) {
            System.out.println("item: " + item);
        }
    };
}

L'avantage de l'utilisation d'un compose avec un Transformer au lieu d'un flatMap avec un Func1 est que si dans l'avenir, si vous avez besoin de mettre à plat une liste de nouveau, vous n'aurez même pas à penser à ce qui opérateur à utiliser (à la carte? flatMap? concatMap?). En d'autres termes, la flatmap opération est ancré dans la FlattenTransform classe et ce détail est rendue abstraite.

Transformateurs ont également d'autres avantages, comme la possibilité de chaîner plusieurs opérations.