我可以获取项目列表，并基于id获得唯一列表，并在一个流动的两个列表？

Question

我可以在Flowable中获取所有这些信息吗？或者我需要订阅shoppingListItems，然后在单独的Flowable中基于这个列表有唯一的recipeID列表

如果可能的话，哪一个是最好的解决方案

Answer 1

假设，您有购物项目，并且您希望获取每个唯一的接收器信息：

环境：：

>

Rxjava 2.0.7

@Test
void name() {
    Observable<Tuple2<ShoppingListItem, Recep>> tuple = getFromDb().flatMapIterable(i -> i)
            .groupBy(shoppingListItem -> shoppingListItem.recepId)
            .flatMap(g -> {
                Observable<Recep> recep = getRecep(g.getKey());
                return Observable.combineLatest(recep, g, (recep1, shoppingListItem) -> {
                    return Tuple.of(shoppingListItem, recep1);
                });
            });
    TestObserver<Tuple2<ShoppingListItem, Recep>> test = tuple.test()
            .assertValueCount(4)
            .assertComplete()
            .assertNoErrors();

    List<Tuple2<ShoppingListItem, Recep>> values = test.values();

    assertThat(values).extracting("_1").extracting("recepId").contains(0, 1);
    assertThat(values).extracting("_1").extracting("id").containsExactly(0, 1, 2, 3);
    assertThat(values).extracting("_2").extracting("id").containsExactly(1, 1, 0, 0);
}

Observable<List<ShoppingListItem>> getFromDb() {
    List<ShoppingListItem> shoppingListItems = Arrays.asList(
            new ShoppingListItem(0, 1),
            new ShoppingListItem(1, 1),
            new ShoppingListItem(2, 0),
            new ShoppingListItem(3, 0)
    );

    return Observable.just(shoppingListItems);
}

Observable<Recep> getRecep(int id) {
    return Observable.just(new Recep(id));
}

class Recep {
    private final int id;

    public Recep(int id) {
        this.id = id;
    }
}

class ShoppingListItem {
    private final int id;

    private final int recepId;

    public ShoppingListItem(int id, int recepId) {
        this.id = id;
        this.recepId = recepId;
    }
}

@Test
void name() {
    Observable<Items> itemsObservable = getFromDb().flatMapSingle(shoppingListItems -> {
        List<Integer> collect = shoppingListItems.stream().map(i -> i.recepId)
                .distinct()
                .collect(Collectors.toList());

        return Observable.fromIterable(collect).flatMap(this::getRecep)
                .toList()
                .zipWith(Single.just(collect), (receps, integers) -> {
                    return new Items(receps, shoppingListItems);
                });
    });

    TestObserver<Items> test = itemsObservable.test()
            .assertValueCount(1)
            .assertComplete()
            .assertNoErrors();

    Items items = test.values().get(0);

    assertThat(items.receps).hasSize(2);
    assertThat(items.shoppingListItems).hasSize(4);
}


Observable<List<ShoppingListItem>> getFromDb() {
    List<ShoppingListItem> shoppingListItems = Arrays.asList(
            new ShoppingListItem(0, 1),
            new ShoppingListItem(1, 1),
            new ShoppingListItem(2, 0),
            new ShoppingListItem(3, 0)
    );

    return Observable.just(shoppingListItems);
}

Observable<Recep> getRecep(int id) {
    return Observable.just(new Recep(id));
}

class Items {
    private final List<Recep> receps;
    private final List<ShoppingListItem> shoppingListItems;

    Items(List<Recep> receps, List<ShoppingListItem> shoppingListItems) {
        this.receps = receps;
        this.shoppingListItems = shoppingListItems;
    }
}

class Recep {
    private final int id;

    public Recep(int id) {
        this.id = id;
    }
}

class ShoppingListItem {
    private final int id;

    private final int recepId;

    public ShoppingListItem(int id, int recepId) {
        this.id = id;
        this.recepId = recepId;
    }
}