标签: rx-java

如何计算RxJava中的移动平均线

在金融领域,我们通常需要从时间序列数据流中计算移动窗口聚合值,以移动平均值为例,假设我们有以下数据流(T是时间戳,V是实际值):

[T0,V0],[T1,V1],[T2,V2],[T3,V3],[T4,V4],[T5,V5],[T6,V6],[T7,V7],[T8,V8],[T9,V9],[T10,1V0],......
Run Code Online (Sandbox Code Playgroud)

从流中计算出移动平均线3:

avg([T0,V0],[T1,V1],[T2,V2]),
avg([T1,V1],[T2,V2],[T3,V3]),
avg([T2,V2],[T3,V3],[T4,V4]),
avg([T3,V3],[T4,V4],[T5,V5]),
avg([T4,V4],[T5,V5],[T6,V6]),...
Run Code Online (Sandbox Code Playgroud)

为了计算移动平均线,似乎我们可以通过以下方式来实现:

  1. 从原始流构建一个Observable
  2. 通过将值聚合到组中,从原始流构建Observable
  3. 使用聚合运算符计算步骤2中Observable的最终结果.

步骤1和3很容易实现,但是,对于第2步,似乎当前的RxJava没有内置运算符来生成移动窗口组,窗口/ groupBy运算符似乎不适合这种情况,我没有找到从现有运营商构建解决方案的简单方法,任何人都可以建议如何以"优雅"的方式在RxJava中执行此操作吗?

reactive-programming rx-java

7
推荐指数
1
解决办法
3044
查看次数

将RX Observable传递给actor(scala)是否安全?

我一直在为RX Java使用scala绑定一段时间了,我正在考虑将它与Akka Actors结合起来.我想知道Observable在Akka Actors 之间传递RX是否安全/可能.例如,一个程序可以打印最多20个(每秒)整数的正方形:

/* producer creates an observable and sends it to the worker */
object Producer extends Actor {
  val toTwenty : Observable[Int] = Observable.interval(1 second).take(20)

  def receive = {
    case o : Observable[Int] =>
      o.subscribe( onNext => println )
  }

  worker ! toTwenty
}


/* worker which returns squares of even numbers */
object Worker extends Actor {
  def receive = {
    case o : Observable[Int] => 
       sender ! o filter …
Run Code Online (Sandbox Code Playgroud)

scala akka rx-java

7
推荐指数
2
解决办法
2490
查看次数

将subscribeOn与Retrofit一起使用

关于何时以及是否subscribeOn与Retrofit 一起使用存在冲突的信息.

这是一个不使用的答案subscribeOn.
这个答案似乎意味着subscribeOn没有好的默认设置.
这是使用的示例代码subscribeOn.

那么,一劳永逸,何时应该使用subscribeOn和使用什么线程?使用或不使用的可能后果是subscribeOn什么?

apiService.issueRequest()
    // Is this useful? Required? Bad practice?
    .subscribeOn(Schedulers.io())
    // Do actions on main thread
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Action1<Response>() {
        @Override public void call(Response response) {
            handleResponse(response);
    });
Run Code Online (Sandbox Code Playgroud)

android rx-java retrofit

7
推荐指数
1
解决办法
1301
查看次数

现在可以在哪里找到AndroidObservable.fromBroadcast?

在1.0.0之前,RxAndroid中有AndroidObservable类的fromBroadcast方法, 用于以反应方式订阅广播.在Grokking RxJava中提到过:

我也喜欢AndroidObservable.fromBroadcast(),它允许你创建一个Observable像一个像BroadcastReceiver.这是一种在网络连接发生变化时得到通知的方法:

IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
AndroidObservable.fromBroadcast(context, filter)
                 .subscribe(intent -> handleConnectivityChange(intent));
Run Code Online (Sandbox Code Playgroud)

在1.0.0之后,RxAndroid放弃了很多功能并分成了RxAndroid本身,现在它只有线程化的东西,RxLifecycle和RxBindings.

他们似乎都不包含AndroidObservable与fromBroadcast或fromSharedPreferenceChange.

它是在一些实际和支持的库中实现的吗?

java android broadcastreceiver rx-java

7
推荐指数
1
解决办法
3015
查看次数

RxJava订阅阻止可观察

我想要实现以下目标:

String result = myObservable.toBlocking().first();
Run Code Online (Sandbox Code Playgroud)

即它就像一个常规函数调用。但是,这永远不会发生,因为您需要订阅它,我不知道该怎么做。如果我订阅它,结果将在另一个范围内,并且代码非常丑陋,因为无论如何我只能像常规可观察到的那样得到结果,因此将其变成阻塞可观察的是没有意义的。

rx-java

7
推荐指数
1
解决办法
9937
查看次数

如何处理主线程中的RxAndroid错误

我是rxJava/Android的新手并且惊讶于我的onErrorlambda有时被称为主线程,有时候不会,尽管我使用.observeOn(AndroidSchedulers.mainThread())

示例1:onError在主线程上,
它按预期工作:在主线程onError上调用

Observable.error(new RuntimeException("RTE"))
    .subscribeOn(Schedulers.newThread())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(s -> {
                Log.e(TAG, "onNext("+s+")-thread: " + Thread.currentThread().getName());
            },
            throwable -> {
                Log.e(TAG, "onError()-thread: " + Thread.currentThread().getName());
            });
Run Code Online (Sandbox Code Playgroud)

日志输出:

onError()-thread: main
Run Code Online (Sandbox Code Playgroud)

示例2:onError 不在主线程上

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("one and only");
    }
})
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.timeout(1, TimeUnit.SECONDS)
.subscribe(s -> {
        Log.e(TAG, "onNext("+s+")-thread: " + Thread.currentThread().getName());
    },
    throwable -> {
        Log.e(TAG, "onError()-thread: " + Thread.currentThread().getName());
    });
Run Code Online (Sandbox Code Playgroud)

输出是这样的: …

error-handling rx-java rx-android

7
推荐指数
2
解决办法
3617
查看次数

7
推荐指数
1
解决办法
2140
查看次数

在RxJava 2中正确使用Observable.create()(最佳实践)

我目前正在构建一个利用RxJava 2和Firebase的小型社交媒体风格的应用程序.我正在使用MVP样式架构,并且我使用名为AuthSource的接口抽象出了我的AuthService.

为简单起见,我将在我的服务中使用Single方法:

public class FirebaseAuthService implements AuthSource {

private FirebaseAuth auth;
private FirebaseAuth.AuthStateListener listener;

//initialization code

@Override
public Maybe<User> getUser() {
    return Maybe.create(new MaybeOnSubscribe<User>() {
                            @Override
                            public void subscribe(final MaybeEmitter<User> e) throws Exception {
                                if (auth == null) {
                                    auth = FirebaseAuth.getInstance();
                                }

                                if (listener != null) {
                                    auth.removeAuthStateListener(listener);
                                }

                                listener = new FirebaseAuth.AuthStateListener() {
                                    @Override
                                    public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
                                        FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
                                        auth.removeAuthStateListener(listener);
                                        if (firebaseUser != null) {
                                            User user = …
Run Code Online (Sandbox Code Playgroud)

java android rx-java rx-android rx-java2

7
推荐指数
1
解决办法
4969
查看次数

RxJava2去抖功能在RecyclerView - Android中无法正常工作

我正在尝试创建一个自定义ImageButton,当用户停止单击按钮1秒钟时,它将累积点击并触发事件.

我用debounce函数来完成这个.

自定义ImageButton:

public class MBImageButton extends ImageButton {

    private AtomicInteger mCounter;
    private Disposable mDisposable;
    private Observable<Object> observable;
    private OnAccumulatedRequestsRead mOnAccumulatedRequestsRead;
    private OnEverClickListener mOnEverClickListener;
    private int emitEveryMilli = 1000; // every 1 second by default
    private boolean shouldDisposeOnDetachFromWindow = true;

    public MBImageButton(Context context) {
        super(context);
        init();
    }

    public MBImageButton(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public MBImageButton(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    public void setAccumulatedClickListeners(OnEverClickListener onEverClickListener,
                                             OnAccumulatedRequestsRead onAccumulatedRequestsRead) {
        setOnAccumulatedRequestsRead(onAccumulatedRequestsRead);
        setOnEverClickListener(onEverClickListener);
        initClickObservable(); …
Run Code Online (Sandbox Code Playgroud)

android reactive-programming rx-java rx-android rx-java2

7
推荐指数
1
解决办法
985
查看次数

Observable优于Flowable的实际优势是什么?

2.0中的不同之处描述了Observable和之间的区别Flowable.然而,Observable主要是根据与之相比缺乏的特征来描述Flowable.Observable提到的只有一个显着特征:

使用Observable通常比开销更低Flowable.

但即便如此,这似乎与Observable少数元素更有利的建议相矛盾,并且更有可能导致OutOfMemoryError过于严重的任务.这似乎表明Flowable通常更有效率.

另一件令我困惑的事情是,如果Observable对于少于1K元素Flowable的用例是优选的,并且对于具有超过10K元素的用例是优选的,则具有1K和10K元素之间的用例是灰色区域.

是否有更多技术解释Observable和Flowable?之间的差异? 特别是提出了一种实用的启发式方法,用于决定在1K和10K元素之间的灰色区域中使用哪种方法,或者当元素的数量未知或可能改变时.

相关:此问答仅引用文档而无需进一步说明.

rx-java rx-java2

7
推荐指数
1
解决办法
557
查看次数