对RxJava中缓冲区的错误理解

我正在努力熟悉RxJava。以下是我试图实现的用例：

我的屏幕上有一个按钮，我正试图收集点击次数。因此，如果用户点击该按钮，则会记录一次点击并生成一个日志。现在，如果用户点击按钮两次，那么它会记录两次点击，收集它们并输出2而不是1

从本质上说，我试图在一段时间内累积点击次数，然后吐出最终结果。我猜“”是我需要使用的方法。我在Android中快速创建了一个示例（代码如下），但是buffer方法似乎不像收集所有事件输入并抛出一个集合那样简单

public class DemoFragment
    extends Fragment {

    private int _tapCount = 0;
    private Observable<List<Integer>> _bufferedObservable;
    private Observer<List<Integer>> _observer;

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        _setupLogger();

        _bufferedObservable = _getBufferedObservable();
        _observer = _getObserver();
    }


    // the library butterknife allows this
    @OnClick(R.id.btn_start_operation)
    public void onButtonTapped() {
        _log("GOT A TAP");
        _bufferedObservable.subscribeOn(Schedulers.io())
                         .observeOn(AndroidSchedulers.mainThread())
                         .subscribe(_observer);
    }

    private Observable<List<Integer>> _getBufferedObservable() {
        return Observable.create(new Observable.OnSubscribe<Integer>() {


            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);   // send one tap here
            }

        }).buffer(2, TimeUnit.SECONDS); // collect all taps in the last 2s
    }

    private Observer<List<Integer>> _getObserver() {
        return new Observer<List<Integer>>() {


            @Override
            public void onCompleted() {
                _log(String.format("%d taps", _tapCount));
                _tapCount = 0; // reset tap count
            }

            @Override
            public void onError(Throwable e) {}

            @Override
            public void onNext(List<Integer> integers) {
                if (integers.size() > 0) {
                    for (int i : integers) {
                        _tapCount += i;
                    }
                    onCompleted();
                } else {
                    _log("No taps received");
                }
            }
        };
    }

    // ... other method that help wiring up the example (irrelevant to RxJava)
}

公共类DemoFragment
扩展片段{
私有整数_tapCount=0；
私有可观测_缓冲可观测；
私人观察员；
@凌驾
ActivityCreated上的公共无效（@Nullable Bundle savedinStateCState）{
super.onActivityCreated（savedInstanceState）；
_setupLogger（）；
_bufferedObservable=_getBufferedObservable（）；
_观察者=_getObserver（）；
}
//库butterknife允许这样做
@OnClick（R.id.btn\u启动\u操作）
public void onButtonTapped（）{
_日志（“得到一个水龙头”）；
_bufferedObservable.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（_观察员）；
}
私有可观测_getBufferedObservable（）{
返回Observable.create（newobservable.OnSubscribe（）{
@凌驾
public void call（订户这里有一个代码，显示我将如何执行此操作（假设您的按钮id为
R.id.rx_button
）：

我认为最好使用awesome库来实现这一点。我认为解决方案更干净，尤其是使用lambdas时。我使用了filter操作符，因此我只在onNext（）中得到结果，其中用户在给定的2秒内按了5次以上

我基于（）中的一个示例，该示例使用旧的rx绑定依赖项

@Override
public void onResume() {
    super.onResume();
    mClickSubscription = getBufferedSubscription();
}

@Override 
public void onPause() {
    super.onPause();
    mClickSubscription.unsubscribe();
} 

private Subscription getBufferedSubscription() {
    return RxView.clicks(rx_button)
            .map(aVoid -> 1)
            .buffer(2, TimeUnit.SECONDS)
            .filter(integers -> integers.size() > 5)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<List<Integer>>() {

                @Override
                public void onCompleted() {
                    // fyi: you'll never reach here
                }

                @Override
                public void onError(Throwable e) {
                    SLog.i("Dang error! check your logs");
                }

                @Override
                public void onNext(List<Integer> integers) {
                    SLog.i(String.format("%d taps", integers.size()));

                }
            });
}

@覆盖
恢复时公开作废（）{
super.onResume（）；
mClickSubscription=getBufferedSubscription（）；
}
@凌驾
公共无效暂停（）{
super.onPause（）；
mClickSubscription.unsubscripte（）；
} 
私有订阅getBufferedSubscription（）{
返回RxView.点击（接收按钮）
.map（避免->1）
.缓冲区（2，时间单位。秒）
.filter（整数->整数.size（）>5）
.observeOn（AndroidSchedulers.mainThread（））
.订阅（新观察员）{
@凌驾
未完成的公共无效（）{
//仅供参考：你永远也到不了这里
}
@凌驾
公共无效申报人（可丢弃的e）{
SLog.i（“该死的错误！检查日志”）；
}
@凌驾
public void onNext（列出整数）{
SLog.i（String.format（“%d taps”，integers.size（））；
}
});
}
试试下面的代码：

public class BufferExampleActivity extends AppCompatActivity {

    private static final String TAG = BufferExampleActivity.class.getSimpleName();
    Button btn;
    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example);
        btn = (Button) findViewById(R.id.btn);
        textView = (TextView) findViewById(R.id.textView);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                doSomeWork();
            }
        });
    }

    /*
     * simple example using buffer operator - bundles all emitted values into a list
     */
    private void doSomeWork() {

        Observable<List<String>> buffered = getObservable().buffer(3, 1);

        // 3 means,  it takes max of three from its start index and create list
        // 1 means, it jumps one step every time
        // so the it gives the following list
        // 1 - one, two, three
        // 2 - two, three, four
        // 3 - three, four, five
        // 4 - four, five
        // 5 - five

        buffered.subscribe(getObserver());
    }

    private Observable<String> getObservable() {
        return Observable.just("one", "two", "three", "four", "five");
    }

    private Observer<List<String>> getObserver() {
        return new Observer<List<String>>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, " onSubscribe : " + d.isDisposed());
            }

            @Override
            public void onNext(List<String> stringList) {
                textView.append(" onNext size : " + stringList.size());
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onNext : size :" + stringList.size());
                for (String value : stringList) {
                    textView.append(" value : " + value);
                    textView.append(AppConstant.LINE_SEPARATOR);
                    Log.d(TAG, " : value :" + value);
                }

            }

            @Override
            public void onError(Throwable e) {
                textView.append(" onError : " + e.getMessage());
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onError : " + e.getMessage());
            }

            @Override
            public void onComplete() {
                textView.append(" onComplete");
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onComplete");
            }
        };
    }
}

公共类BufferExampleActivity扩展了AppCompativity{
私有静态最终字符串标记=BufferExampleActivity.class.getSimpleName（）；
按钮btn；
文本视图文本视图；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_示例）；
btn=（按钮）findViewById（R.id.btn）；
textView=（textView）findViewById（R.id.textView）；
btn.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
doSomeWork（）；
}
});
}
/*
*使用缓冲区运算符的简单示例-将所有发出的值捆绑到一个列表中
*/
私人文件{
Observable buffered=getObservable（）.buffer（3,1）；
//3意味着，它从开始索引和创建列表中最多取三个
//1表示每次跳一步
//因此，它给出了以下列表
//一，二，三
//2-2，3，4
//3-3，4，5
//4-4，5
//5-5
subscribe（getObserver（））；
}
私有可观察getObservable（）{
可观察的回报。只是（“一”、“二”、“三”、“四”、“五”）；
}
私有观察者getObserver（）{
返回新的观察者（）{
@凌驾
认购的公共无效（一次性d）{
Log.d（标记为“onSubscribe:+d.isDisposed（））；
}
@凌驾
public void onNext（列表字符串列表）{
textView.append（“onNext size:+stringList.size（））；
textView.append（AppConstant.LINE_分隔符）；
Log.d（标记“onNext:size:+stringList.size（））；
用于（字符串值：stringList）{
textView.append（“值：”+value）；
textView.append（AppConstant.LINE_分隔符）；
Log.d（标记：“：值：”+值）；
}
}
@凌驾
公共无效申报人（可丢弃的e）{
append（“onError:+e.getMessage（））；
textView.append（AppConstant.LINE_分隔符）；
Log.d（标记“onError:+e.getMessage（））；
}
@凌驾
未完成的公共空间（）{
textView.append（“onComplete”）；
textView.append（AppConstant.LINE_分隔符）；
Log.d（标签“未完成”）；
}
};
}
}
首先，哪一个？“Buffer”不是运算符。建议Buffer是运算符。不，它不是。似乎有一种称为“operator Buffer”的东西，但它不能转换为“Buffer是我应该使用的运算符”。Buffer（）是一种方法
@Override
public void onResume() {
    super.onResume();
    mClickSubscription = getBufferedSubscription();
}

@Override 
public void onPause() {
    super.onPause();
    mClickSubscription.unsubscribe();
} 

private Subscription getBufferedSubscription() {
    return RxView.clicks(rx_button)
            .map(aVoid -> 1)
            .buffer(2, TimeUnit.SECONDS)
            .filter(integers -> integers.size() > 5)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<List<Integer>>() {

                @Override
                public void onCompleted() {
                    // fyi: you'll never reach here
                }

                @Override
                public void onError(Throwable e) {
                    SLog.i("Dang error! check your logs");
                }

                @Override
                public void onNext(List<Integer> integers) {
                    SLog.i(String.format("%d taps", integers.size()));

                }
            });
}

public class BufferExampleActivity extends AppCompatActivity {

    private static final String TAG = BufferExampleActivity.class.getSimpleName();
    Button btn;
    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example);
        btn = (Button) findViewById(R.id.btn);
        textView = (TextView) findViewById(R.id.textView);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                doSomeWork();
            }
        });
    }

    /*
     * simple example using buffer operator - bundles all emitted values into a list
     */
    private void doSomeWork() {

        Observable<List<String>> buffered = getObservable().buffer(3, 1);

        // 3 means,  it takes max of three from its start index and create list
        // 1 means, it jumps one step every time
        // so the it gives the following list
        // 1 - one, two, three
        // 2 - two, three, four
        // 3 - three, four, five
        // 4 - four, five
        // 5 - five

        buffered.subscribe(getObserver());
    }

    private Observable<String> getObservable() {
        return Observable.just("one", "two", "three", "four", "five");
    }

    private Observer<List<String>> getObserver() {
        return new Observer<List<String>>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, " onSubscribe : " + d.isDisposed());
            }

            @Override
            public void onNext(List<String> stringList) {
                textView.append(" onNext size : " + stringList.size());
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onNext : size :" + stringList.size());
                for (String value : stringList) {
                    textView.append(" value : " + value);
                    textView.append(AppConstant.LINE_SEPARATOR);
                    Log.d(TAG, " : value :" + value);
                }

            }

            @Override
            public void onError(Throwable e) {
                textView.append(" onError : " + e.getMessage());
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onError : " + e.getMessage());
            }

            @Override
            public void onComplete() {
                textView.append(" onComplete");
                textView.append(AppConstant.LINE_SEPARATOR);
                Log.d(TAG, " onComplete");
            }
        };
    }
}