我有以下代码:
public void foo() {
Long[] gData = new Long[] { 1L, 2L };
rx.Observable.from(gData)
.concatMap(data -> {
rx.Observable<GmObject> depositObs1 = depositToUserBalance(data, 1);
rx.Observable<GmObject> depositObs2 = depositToUserBalance(data, 2);
return rx.Observable.zip(depositObs1, depositObs2, (depositObj1, depositObj2) -> {
depositObj1.putNumber("seat_index", data);
depositObj2.putNumber("seat_index", data);
return rx.Observable.merge(
rx.Observable.just(depositObj1),
rx.Observable.just(depositObj2));
})
})
.reduce(new ArrayList<Long>(), (payoutArr, payoutObj) -> {
int seatIndex = ((GmObject) payoutObj).getNumber("seat_index").intValue();
long payout = ((GmObject) payoutObj).getNumber("payout").longValue();
payoutArr.add(seatIndex, payout);
return payoutArr;
})
.subscribe(results -> {
System.out.println(results);
});
}
Run Code Online (Sandbox Code Playgroud)
此代码使用.zip发送到observable,然后添加'seat_index'属性并调用.merge以使用.reduce,因此最终所有结果将聚合到ArrayList中.
这段代码有一个问题:当.reduce处理它的输入时,它将它作为Observable而不是GmObject ...什么函数可以从它的Observable包中"提取"GmObject?
以这种方式使用rxJava是否有意义?还是有更好的技术?
谢谢!
我正在制作Android应用程序,有一个初学者的问题:有没有办法推迟Observables排放,直到2个订阅者订阅?因为我不希望第二个错过数据.谢谢
我有一个关于RxJava Observable的问题.例如,我有一个Retrofit接口,它返回Observable.我需要对这个视频流做一些事情.以下是下载视频并将其保存到列表中的代码:
API.getVideoListObservable()
.doOnError(t -> t.printStackTrace())
.map(r -> r.getObjects())
.doOnNext(l -> VideoActivity.this.runOnUiThread(() -> fragment.updateVideoList(l)))
.doOnNext(l -> kalturaVideoList.addAll(l))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
Run Code Online (Sandbox Code Playgroud)
API - 改造休息适配器
如果想更新视频列表,我应该做同样的操作吗?或者我应该订阅,取消订阅并再次订阅如下:
Subscription s = API.getVideoListObservable()
.doOnError(t -> t.printStackTrace())
.map(r -> r.getObjects())
.doOnNext(l -> VideoActivity.this.runOnUiThread(() -> fragment.updateVideoList(l)))
.doOnNext(l -> kalturaVideoList.addAll(l))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
//some code
...
s.unsubscribe();
s = null;
s = API.getVideoListObservable()
.doOnError(t -> t.printStackTrace())
.map(r -> r.getObjects())
.doOnNext(l -> VideoActivity.this.runOnUiThread(() -> fragment.updateVideoList(l)))
.doOnNext(l -> kalturaVideoList.addAll(l))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
Run Code Online (Sandbox Code Playgroud) 如果我有一个带整数的列表,有没有办法构建另一个列表,如果新列表的头部差异低于threashold,则整数总和?我想用Java 8流来解决这个问题.它应该类似于RxJava 的Scan运算符.
Example: 5, 2, 2, 5, 13
Threashold: 2
Result: 5, 9, 13
Intermediate results:
5
5, 2
5, 4 (2 and 2 summed)
5, 9 (4 and 5 summed)
5, 9, 13
Run Code Online (Sandbox Code Playgroud) 我有一个布尔可观察的(通过观察者)启动和停止Android服务.当传递true时,服务必须立即启动.当错误通过时,我想在不久之后出现错误的情况下去辩论,以避免不必要的(和破坏性的)停止和启动服务.是否有标准运算符的组合可以执行此操作,或者我必须自己编写,如果是,我应该基于它OperatorDebounceWithTime.java还是有更简单的方法?谢谢!
我正在尝试使用rx-java构建一个健壮的处理管道,但我遇到了一个问题.
这是一个例子:
public static void main(String[] args) {
AtomicInteger div = new AtomicInteger(-1);
Observable.just(1, 1, 1).map(item -> 1 / div.getAndIncrement())
.retry().subscribe(item -> System.out.println(item));
}
Run Code Online (Sandbox Code Playgroud)
在这种情况下的输出是4项,因为非流可观察被重放,但这不相关所以为了简单起见,请忽略它.我添加了评论,显示了达到结果的计算和重新订阅的重点:
-1 // 1 / -1
// 1/0 (error) - resubscribes to observable
1 // 1 / 1
0 // 1 / 2
0 // 1 / 3
Run Code Online (Sandbox Code Playgroud)
发生这种情况是因为retry操作员(作为所有重试操作符)在传递错误通知后导致重新订阅.
我的预期输出是:
-1 // 1 / -1
// 1/0 (error) - resubscribe but resume erroneous item (1)
1 // 1 / 1
0 // 1 / …Run Code Online (Sandbox Code Playgroud) 在用RxJava编写数据同步作业时,我发现了一个我无法解释的奇怪行为.我是RxJava的新手,非常感谢帮助.
简而言之,我的工作非常简单我有一个元素ID列表,我调用web服务来获取每个元素的ID,进行一些处理并进行多次调用以将数据推送到DB.数据加载比数据存储更快,因此我输入了OutOfMemory错误.
我的代码几乎看起来像"失败"测试,但后来做了一些测试我意识到删除线:
flatMap(dt -> Observable.just(dt))
Run Code Online (Sandbox Code Playgroud)
让它起作用.失败的测试输出清楚地表明未消耗的项目叠加,这导致OutOfMemory.工作测试输出显示生产者将始终等待消费者,因此这永远不会导致OutOfMemory.
public static class DataStore {
public Integer myVal;
public byte[] myBigData;
public DataStore(Integer myVal) {
this.myVal = myVal;
this.myBigData = new byte[1000000];
}
}
@Test
public void working() {
int MAX_CONCURRENT_LOAD = 1;
int MAX_CONCURRENT_STORE = 2;
AtomicInteger nbUnconsumed = new AtomicInteger(0);
List<Integer> ids = IntStream.range(0, 1000).boxed().collect(Collectors.toList());
Observable.from(ids)
.flatMap(this::produce, MAX_CONCURRENT_LOAD)
.doOnNext(s -> logger.info("+1 Total unconsumed values: " + nbUnconsumed.incrementAndGet()))
.flatMap(this::consume, MAX_CONCURRENT_STORE)
.doOnNext(s -> logger.info("-1 Total unconsumed values: " + nbUnconsumed.decrementAndGet()))
.toBlocking().forEach(s -> {}); …Run Code Online (Sandbox Code Playgroud) 当我第一次进入Android中的反应式编程时,我发现rxJava和rxAndroid更喜欢世界上许多开发人员.但是今天我发现了另一个名为agera of Google的库,它仍在维护过程中(最后一次提交是2个月前).
它看起来像rxJava乍一看,但有更有意义的api名称,这有助于我轻松理解反应式编程.更重要的是,谷歌的优秀开发人员正在他们的项目中使用它(Google Play电影),我相信这是有道理的.
我想知道Google agera是否应该更轻量级?与rxJava和rxAndroid相比,性能如何呢?有没有大公司在生产中使用它?我是否需要学习它才能理解Android中的反应式编程?
我试图了解delay和delaySubscription运算符之间的区别。
本文档描述了延迟运算符:
延迟运算符通过在发出每个源Observable项目之前暂停特定的时间增量(由您指定)来修改其源Observable。这样的效果是将Observable发出的整个项目序列按时间向前移动指定的增量
delaySubscription的描述如下:
还有一个运算符,可用于延迟对源Observable的订阅:delaySubscription。
但是,当我测试这两个运算符的行为时,在我看来它们的工作方式相同。
这是我的观察:
Observable observable = Observable.just(5, 3, 4, 2);
Run Code Online (Sandbox Code Playgroud)
在这里我使用延迟运算符:
observable = observable.delay(3, TimeUnit.SECONDS);
Run Code Online (Sandbox Code Playgroud)
这是我的观察者,它记录何时调用其方法之一
Observer observer = new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.d("RxJavaTag", "onSubscribe");
}
@Override
public void onNext(Object o) {
Log.d("RxJavaTag", "onNext: " + o);
}
@Override
public void onError(Throwable e) {
Log.d("RxJavaTag", "onError:" + e.toString());
}
@Override
public void onComplete() {
Log.d("RxJavaTag", "onComplete");
}
};
Run Code Online (Sandbox Code Playgroud)
观察者在这里订阅了可观察者:
observable.subscribe(observer);
Run Code Online (Sandbox Code Playgroud)
结果,当我使用延迟 …
rx-java ×10
java ×5
android ×2
java-8 ×1
java-stream ×1
observable ×1
reactivex ×1
rx-android ×1
rx-java2 ×1