RXJava - 拆分和组合 Observable答案

【问题标题】：RXJava - Split and Combine an ObservableRXJava - 拆分和组合 Observable
【发布时间】：2015-05-12 23:11:15
【问题描述】：

我是 RxJava 新手，需要一些关于如何执行以下操作的帮助/指导：

我需要从 Observable 中获取两个值

一个字符串

一个列表<.objecta>

然后我需要在这个列表上应用两个不同的过滤器（），然后最后将它们（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());
        }
    });

}

【问题讨论】：

标签： android system.reactive rx-java

【解决方案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"));
    }
}

【讨论】：