的Rx爪哇 - 疑難案件

Observable<Integer> obs = Observable.just(1, 2, 3, 4, 5);

我需要一個序列，其中每個偶數obs乘以在obs甚至號的數量，以及每個奇數obs乘以obs中的奇數數字。

I.e.在給定的情況下，有2埃文斯和3倍的賠率，所以結果序列必須

3 (1 * 3) 
4 (2 * 2) 
9 (3 * 3) 
8 (4 * 2) 
15 (5 * 3)

我該怎麼辦呢？

來源

2017-05-07 Alexey

您可以分裂Observable奇數實現它，甚至流，然後遍歷每個流和每個分流的數量乘以：

Observable<Integer> obs = Observable.just(1, 2, 3, 4, 5); 
Observable<Integer> oddsObservable = obs.filter(integer -> integer % 2 == 1); 
Observable<Integer> evenObservable = obs.filter(integer -> integer % 2 == 0); 
Observable.merge(
     oddsObservable.flatMap(odd -> oddsObservable.count().map(count -> odd * count)), 
     evenObservable.flatMap(even -> evenObservable.count().map(count -> even * count)) 
) 
     .sorted() 
     .subscribe(System.out::println);

，如果你在做內存你可以考慮使用Java 8 Stream API，做相同的列表/陣列，代碼非常相似：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); 
List<Integer> oddsList = list.stream().filter(integer -> integer % 2 == 1).collect(Collectors.toList()); 
List<Integer> evenList = list.stream().filter(integer -> integer % 2 == 0).collect(Collectors.toList()); 

Stream.of(oddsList.stream().map(odd -> odd * (int) oddsList.stream().count()), 
    evenList.stream().map(even -> even * (int) evenList.stream().count())) 
    .flatMap(integerStream -> integerStream) 
    .sorted() 
    .forEach(System.out::println);

在我的機器上它的大小（〜X12）的順序運行速度更快。

如果項目/數字ID的一段時間生產源頭考慮優化無功的做法，以避免重新訂閱多次Observables（重播/緩存等）

來源

2017-05-07 19:37:38 yosriz

-1

Observable<Integer> obs = Observable.just(1, 2, 3, 4, 5); 
List<Integer> count = obs.groupBy(i -> i % 2) 
    .sorted((g1, g2) -> g1.getKey() - g2.getKey()) 
    .concatMap(go -> go.count()) 
    .toList() 
    .toBlocking() 
    .first(); 
obs.map(i -> i * count.get(i % 2)) 
    .forEach(System.out::println);

導線的兩倍。

來源

2017-05-08 00:24:02

的Rx爪哇 - 疑難案件

回答

相關問題