RXJava - 分割和合并 Observable

Question

我是RxJava的新手，需要一些帮助/指导，以完成以下操作：

我需要从Observable中获取两个值 1. 一个字符串 2. 一个List 然后，我需要在此列表上应用两个不同的filters()，最后将它们组合成一个单一的observable（包括String、FilteredListA和FilteredListB）。

是否有一个单一的链接调用可以使用？（需要groupBy的示例）

以下是执行相同操作的示例代码。

MasterObject = String, List<.ObjectA>

 Observable<ReturnObject> getReturnObject() { 

        Observable<MasterObject> masterObjectObservable = getMasterObjectObservable();


        Observable<String> myStringbservable = masterObjectObservable.map(new Func1<MasterObject, String>() {
            @Override
            public String call(MasterObject masterObject) {
                return masterObject.getString();
            }
        });

        return  masterObjectObservable.flatMap(new Func1<MasterObject, Observable<ObjectA>>() {
            @Override
            public Observable<MasterObject> call(MasterObject masterObject) {
                return Observable.from(masterObject.getList());
            }
        }).filter(new Func1<ObjectA, Boolean>() {
            @Override
            public Boolean call(ObjectA objectA) {
                return objectA.isTrue();
            }
        }).toList().concatWith(getSecondList(masterObjectObservable)).zipWith(publicKeyObservable, new Func2<List<ObjectA>, String, ReturnObject>() {
            @Override
            public ReturnObject call(List<ObjectA> listObjectA, String string) {
                return new ReturnObject(string, listObject);
            }
        });
}


private Observable<List<ObjectA>> getSecondList(Observable<MasterObject> masterObject) {
   return masterObject.flatMap(new Func1<MasterObject, Observable<ObjectA>>() {
        @Override
        public Observable<ObjectA> call(MasterObject masterObject) {
            return Observable.from(masterObject.getList());
        }
    }).filter(new Func1<ObjectA, Boolean>() {
        @Override
        public Boolean call(ObjectA objectA) {
            return objectA.isCondition();
        }
    }).toSortedList(new Func2<ObjectA, ObjectA, Integer>() {
        @Override
        public Integer call(ObjectA a, ObjectA b) {
            return a.getCondition()
                    .compareTo(b.getCondition());
        }
    });

}

- nkz

Answer 1

以下是一个使用groupBy的示例:

public class Multikind2 {
    static Observable<Object> getSource() {
        return Observable.just("String", Arrays.asList(1, 2, 3, 4));
    }

    enum ValueKind {
         STRING, LIST
    }

    public static void main(String[] args) {
        Func1<Object, ValueKind> kindSelector = o -> {
            if (o instanceof String) {
                return ValueKind.STRING;
            } else
            if (o instanceof List) {
                return ValueKind.LIST;
            }
            throw new IllegalArgumentException("Unsupported value: "+ o);
        };

        getSource()
        .groupBy(kindSelector)
        .flatMap(g -> {
            if (g.getKey() == ValueKind.STRING) {
                return g;
            } else
            if (g.getKey() == ValueKind.LIST) {
                Observable<Integer> flattened = g
                        .flatMapIterable(v -> (Iterable<Integer>)v)
                        .share();

                Observable<Integer> filtered1 = flattened
                        .filter(v -> v % 2 == 0);

                Observable<String> filtered2 = flattened
                        .filter(v -> v % 2 != 0)
                        .map(v -> "-> " + v);

                return filtered1.cast(Object.class)
                        .mergeWith(filtered2).cast(Object.class);
            }
            return Observable.<Object>error(
                new IllegalArgumentException("Unsupported value kind: "+ g.getKey()));
        }).subscribe(
            System.out::println, 
            Throwable::printStackTrace, 
            () -> System.out.println("Done"));
    }
}

- akarnokd