钉某人
钉某人

RxJava2操作符篇

Github地址：https://github.com/DingMouRen/RxJava2ExamplesDemo

Rxjava的四个概念：Observable 被观察者，Observer 观察者， subscribe 订阅，事件。

操作符

官网：http://reactivex.io/documentation/operators.html

1.create

作用：可用于获取一个被观察的对象

 Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {

                mTvLog.append("Observable 发射 1\n");
                emitter.onNext(1);

                mTvLog.append("Observable 发射 2\n");
                emitter.onNext(2);

                mTvLog.append("Observable 发射 3\n");
                emitter.onNext(3);

                mTvLog.append("Observable 发射 4\n");
                emitter.onNext(4);

                emitter.onComplete();

            }

        }).subscribe(new Observer() {

            Disposable mDisposable;

            @Override
            public void onSubscribe(Disposable disposable) {
                mDisposable = disposable;
                mTvLog.append("onSubscribe 获取到Disposable实例\n");
            }

            @Override
            public void onNext(Integer integer) {

                mTvLog.append("onNext -- "+integer+"  Disposable的订阅状态:"+mDisposable.isDisposed()+"->"+(mDisposable.isDisposed()?"解除订阅":"订阅中")+"\n");

                if (integer == 2){
                    mDisposable.dispose();
                    mTvLog.append("onNext -- "+integer+"  Disposable的订阅状态:"+mDisposable.isDisposed()+"->"+(mDisposable.isDisposed()?"解除订阅":"订阅中")+"\n");
                }
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError:"+e.getMessage());
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete");
            }
        });

日志：

    onSubscribe 获取到Disposable实例
    Observable 发射 1
    onNext -- 1  Disposable的订阅状态:false->订阅中
    Observable 发射 2
    onNext -- 2  Disposable的订阅状态:false->订阅中
    onNext -- 2  Disposable的订阅状态:true->解除订阅
    Observable 发射 3
    Observable 发射 4
  • 发射2后，调用mDisposable.dispose(),解除订阅关系，后面的观察者Observer就不会接受到onNext()了，但是观察则会Obserable会继续发送剩下的事件3，事件4，
  • ObservableEmitter专门用来发射数据。Disposable是用来解除订阅关系的，isDisposed() 返回为 false 的时候，接收器能正常接收事件，但当其为 true 的时候，接收器停止了接收。

2.just

作用：创建一个被观察对象，接受可变参数，并依次发射参数。

 Observable.just(1,2,3)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer() {
                    Disposable mDisposable;
                    @Override
                    public void onSubscribe(Disposable disposable) {
                        mDisposable = disposable;
                        mTvLog.append("onSubscribe   获取到Disposable实例\n");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        mTvLog.append("onNext -- "+integer+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });

日志：

    onSubscribe   获取到Disposable实例
    onNext -- 1
    onNext -- 2
    onNext -- 3
    onComplete

3.map

作用：通过函数处理observable传递过来的数据（事件）

Observable.just(1,2,3)
                .map(new Function() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        mTvLog.append("map函数处理传递过来的数字\n");
                        //函数处理事件
                        String strResult = "数字变大2倍后："+integer * 2;

                        return strResult;
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer() {
                    Disposable mDisposable;
                    @Override
                    public void onSubscribe(Disposable d) {
                        mDisposable = d;
                        mTvLog.append("onSubscribe 获取到Disposable实例 线程："+Thread.currentThread().getName()+"\n");
                    }

                    @Override
                    public void onNext(String s) {
                        mTvLog.append("onNext : "+s +"  线程:"+Thread.currentThread().getName()+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError   线程:"+Thread.currentThread().getName()+"\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete   线程:"+Thread.currentThread().getName()+"\n");
                        Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });

日志:

    onSubscribe 获取到Disposable实例 线程：main
    map函数处理传递过来的数字
    map函数处理传递过来的数字
    map函数处理传递过来的数字
    onNext : 数字变大2倍后：2  线程:main
    onNext : 数字变大2倍后：4  线程:main
    onNext : 数字变大2倍后：6  线程:main
    onComplete   线程:main
  • map操作符依次处理observable传递过来的数据，处理完后再依次调用onNext()

4.zip

作用：用于合并事件，两两配对合并成 一个事件，最终配对出的 Observable 发射事件数目只和少的那个相同。


zip.png 
  Observable.zip(getNumberObservable(), getLetterObservable(), new BiFunction() {
            @Override
            public String apply(Integer number, String letter) throws Exception {
                mTvLog.append("zip  number:"+number+"  letter:"+letter +"\n");
                return number + letter;
            }


        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe\n");
            }

            @Override
            public void onNext(String result) {
                mTvLog.append("onNext result:"+result+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError "+e.getMessage()+"\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete \n");
                Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }
        });

    //获取数字的Observable实例
    private Observable getNumberObservable(){
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                mTvLog.append("NumberObservalbe 发射 1\n");
                emitter.onNext(1);

                mTvLog.append("NumberObservalbe 发射 2\n");
                emitter.onNext(2);

                mTvLog.append("NumberObservalbe 发射 3\n");
                emitter.onNext(3);

                emitter.onComplete();
            }
        });
    }

    //获取字母的Observable实例
    private Observable getLetterObservable(){
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                mTvLog.append("NumberObservalbe 发射 A\n");
                emitter.onNext("A");

                mTvLog.append("NumberObservalbe 发射 B\n");
                emitter.onNext("B");

                mTvLog.append("NumberObservalbe 发射 C\n");
                emitter.onNext("C");

                mTvLog.append("NumberObservalbe 发射 D\n");
                emitter.onNext("D");

                emitter.onComplete();
            }
        });
    }

日志：

    onSubscribe
    NumberObservalbe 发射 1
    NumberObservalbe 发射 2
    NumberObservalbe 发射 3
    NumberObservalbe 发射 A
    zip  number:1  letter:A
    onNext result:1A
    NumberObservalbe 发射 B
    zip  number:2  letter:B
    onNext result:2B
    NumberObservalbe 发射 C
    zip  number:3  letter:C
    onNext result:3C
    onComplete 
    NumberObservalbe 发射 D
  • 不能被配对的事件，会被舍弃掉

5.flatMap

作用：把一个发射器 Observable 通过某种方法转换为多个 Observables，然后再把这些分散的 Observables装进一个单一的发射器 Observable。flatMap 并不能保证事件的顺序，如果需要保证顺序，需要使用concatmap

image.png 
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(@NonNull ObservableEmitter e) throws Exception {
                mTvLog.append("Observable 发射 1 \n");
                e.onNext(1);

                mTvLog.append("Observable 发射 2 \n");
                e.onNext(2);

                mTvLog.append("Observable 发射 3 \n");
                e.onNext(3);
            }
        }).flatMap(new Function>() {
            @Override
            public ObservableSource apply(@NonNull Integer integer) throws Exception {
                mTvLog.append("flatmap  integer=" + integer + "\n");
                List list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("value :" + integer + " - " + (i+1) );
                }
                int delayTime = (int) (1 + Math.random() * 10);
                return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        mTvLog.append("Consumer accept:" + s + "\n");
                        Log.e(mActivity.getClass().getSimpleName(), mTvLog.getText().toString());
                    }
                });

日志:

    Observable 发射 1 
    flatmap  integer=1
    Observable 发射 2 
    flatmap  integer=2
    Observable 发射 3 
    flatmap  integer=3
    Consumer accept:value :2 - 1
    Consumer accept:value :2 - 2
    Consumer accept:value :3 - 1
    Consumer accept:value :1 - 1
    Consumer accept:value :3 - 2
    Consumer accept:value :3 - 3
    Consumer accept:value :2 - 3
    Consumer accept:value :1 - 2
    Consumer accept:value :1 - 3

6.concatMap

作用：concatMap 与 FlatMap 的唯一区别就是 concatMap 保证了顺序

 Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(@NonNull ObservableEmitter e) throws Exception {
                mTvLog.append("Observable 发射 1 \n");
                e.onNext(1);

                mTvLog.append("Observable 发射 2 \n");
                e.onNext(2);

                mTvLog.append("Observable 发射 3 \n");
                e.onNext(3);

                e.onComplete();

            }
        }).concatMap(new Function>() {
            @Override
            public ObservableSource apply(@NonNull final Integer integer) throws Exception {

                List list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("value :" + integer + " - " + (i+1) );
                }
                int delayTime = (int) (1 + Math.random() * 10);
                return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe \n" );
            }

            @Override
            public void onNext(String s) {
                mTvLog.append("onNext " + s + "\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError \n" );
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete \n" );
                Log.e(mActivity.getClass().getSimpleName(), mTvLog.getText().toString());
            }
        });

日志：

    onSubscribe 
    Observable 发射 1 
    Observable 发射 2 
    Observable 发射 3 
    onNext value :1 - 1
    onNext value :1 - 2
    onNext value :1 - 3
    onNext value :2 - 1
    onNext value :2 - 2
    onNext value :2 - 3
    onNext value :3 - 1
    onNext value :3 - 2
    onNext value :3 - 3
    onComplete
  • concatMap操作符处理的时候，第一次是在main线程，后面的在计算的线程，这三次发射的线程一次是：main -> RxComputationThreadPool-1 -> RxComputationThreadPool-2

7.filter

作用：符合条件的事件才会被发射出去

  Observable.just(1,2,3,4,5,6)
                .filter(new Predicate() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        mTvLog.append("filter  integer:"+integer+"\n");
                        return integer >3;
                    }
                }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe \n");
            }

            @Override
            public void onNext(Integer integer) {
                mTvLog.append("onNext integer:"+integer+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError \n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete \n");
                Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }
        });

日志：

    onSubscribe 
    filter  integer:1
    filter  integer:2
    filter  integer:3
    filter  integer:4
    onNext integer:4
    filter  integer:5
    onNext integer:5
    filter  integer:6
    onNext integer:6
    onComplete

8.take

作用：接受一个 long 型参数 count ，代表至多接收 count 个数据

mTvLog.append("发射 1 ，2，3，4，5\n");
        Observable.fromArray(1,2,3,4,5)
                .take(2)
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubcribe \n");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        mTvLog.append("onNext integer:"+integer+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });

日志:

    Observable 发射 1 ，2，3，4，5
    onSubcribe 
    onNext integer:1
    onNext integer:2
    onComplete

9.doOnNext

作用：让订阅者在接收到数据之前做一些别的事情

  mTvLog.append("Observable 发射 1\n");
        Observable.just(1)
                .doOnNext(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        mTvLog.append("doOnNext 无返回值 在此保存数据 线程："+Thread.currentThread().getName()+"\n");
                    }
                }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe\n");
            }

            @Override
            public void onNext(Integer integer) {
                mTvLog.append("onNext  integer:"+integer+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete\n");
                Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }
        });

日志：

    Observable 发射 1
    onSubscribe
    doOnNext 无返回值 在此保存数据 线程：main
    onNext  integer:1
    onComplete

10.timer

作用：指定一个延时任务

    Observable.timer(2, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread()) // timer 默认在新线程，所以需要切换回主线程
                .subscribe(new Consumer() {
                    @Override
                    public void accept(@NonNull Long aLong) throws Exception {
                       mTvLog.append(new Date().toString()+" 结束任务\n");
                       Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });

日志：

Wed Dec 19 21:05:38 GMT+08:00 2018 开始执行2延时任务
Wed Dec 19 21:05:40 GMT+08:00 2018 结束任务

11.interval

作用：间隔时间执行某个操作，其接受三个参数，分别是第一次发送延迟，间隔时间，时间单位,默认在新线程。例如倒计时

 mTvLog.append("开始\n");
        mDisposable = Observable.interval(0, 1, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread()) // 由于interval默认在新线程，所以我们应该切回主线程
                .subscribe(new Consumer() {
                    @Override
                    public void accept(@NonNull Long aLong) throws Exception {
                        mTvLog.append(new Date().toString() + " num="+aLong+"\n");
                       Log.e(mActivity.getClass().getSimpleName(),new Date().toString() + " num="+aLong);
                    }
                });

Single

作用：Single只会接收一个参数,而SingleObserver只会调用onError或者onSuccess.只发射一条单一的数据，或者一条异常通知。要么成功，要么失败。

 Single.create(new SingleOnSubscribe() {
            @Override
            public void subscribe(SingleEmitter emitter) throws Exception {
                mTvLog.append("Single 发射 1\n");
                emitter.onSuccess(1);//异常通知与成功通知之间只能发射一个
            }
        }).subscribe(new SingleObserver() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe \n");
            }

            @Override
            public void onSuccess(Integer integer) {
                mTvLog.append("onSuccess integer:"+integer+"\n");
                Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError "+e.getMessage()+"\n");
            }
        });

日志：

    onSubscribe 
    Single 发射 1
    onSuccess integer:1

12.Completable

作用：只发射一条完成通知，或者一条异常通知，不能发射数据，其中完成通知与异常通知只能发射一个

  Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(CompletableEmitter emitter) throws Exception {

                mTvLog.append("Completable 发射 1\n");
                emitter.onComplete();

            }
        }).subscribe(new CompletableObserver() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe \n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete \n");
                Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError \n");
            }
        });

日志：

    onSubscribe 
    Completable 发射 1
    onComplete

13.MayBe

作用：可发射一条单一的数据，以及发射一条完成通知，或者一条异常通知，其中完成通知和异常通知只能发射一个，发射数据只能在发射完成通知或者异常通知之前，否则发射数据无效。

 Maybe.create(new MaybeOnSubscribe() {
            @Override
            public void subscribe(MaybeEmitter emitter) throws Exception {

                mTvLog.append("MayBe 发射 1\n");
                emitter.onSuccess(1);

                emitter.onComplete();

            }
        }).subscribe(new MaybeObserver() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscirbe\n");
                
            }

            @Override
            public void onSuccess(Integer integer) {
                mTvLog.append("onSuccess  integer:"+integer+"\n");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

日志：

    onSubscribe 
    Completable 发射 1
    onComplete

14.skip

作用：接受一个long型参数，代表跳过多少个数目的事件再开始接收

 Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {

                mTvLog.append("Observable 发射 1\n");
                emitter.onNext(1);

                mTvLog.append("Observable 发射 2\n");
                emitter.onNext(2);

                mTvLog.append("Observable 发射 3\n");
                emitter.onNext(3);

                emitter.onComplete();
            }
        }).skip(2)
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        mTvLog.append("onNext  integer:"+integer+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });

日志：

    onSubscribe
    Observable 发射 1
    Observable 发射 2
    Observable 发射 3
    onNext  integer:3
    onComplete

15.concat

作用：把两个发射器连接成一个发射器，有顺序的发射

 Observable.concat(Observable.just(1,2),Observable.just("3"))
        .subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe \n");
            }

            @Override
            public void onNext(Object object) {

                String result = "";
                if (object instanceof Integer){
                    result = (int) object + "";
                }else if (object instanceof String){
                    result = (String) object;
                }

                mTvLog.append("onNext object:"+result+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError \n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onCompelte\n");
                Log.e(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }
        });


日志：


    onSubscribe 
    onNext object:1
    onNext object:2
    onNext object:3
    onCompelte



16.distinct


作用：去重操作符


 Observable.just(1,1,2,2,3)
                .distinct()
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        mTvLog.append("onNext integer:"+integer+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });



日志：


    onSubscribe
    onNext integer:1
    onNext integer:2
    onNext integer:3
    onComplete



17.buffer


作用：将 Observable 中的数据按 skip (步长) 分成最大不超过 count 的 buffer ，然后生成一个 Observable 。


Observable.just(1,2,3,4,5,6,7,8)
                .buffer(3,2)
                .subscribe(new Observer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onNext(List integers) {
                        mTvLog.append("onNext 集合："+ Arrays.toString(integers.toArray())+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError \n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete \n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });



日志：


    onSubscribe
    onNext 集合：[1, 2, 3]
    onNext 集合：[3, 4, 5]
    onNext 集合：[5, 6, 7]
    onNext 集合：[7, 8]
    onComplete 



18.debounce


作用：去除发送频率过快的项


Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {

                emitter.onNext(1);
                mTvLog.append("Observable 发射1 睡490毫秒\n");
                Thread.sleep(490);

                emitter.onNext(2);
                mTvLog.append("Observable 发射2 睡500毫秒\n");
                Thread.sleep(500);

                emitter.onNext(3);
                mTvLog.append("Observalbe 发射3 睡510毫秒\n");
                Thread.sleep(510);

                emitter.onNext(4);
                mTvLog.append("Observalbe 发射3 睡520毫秒\n");
                Thread.sleep(520);

                emitter.onComplete();

            }
        }).debounce(500, TimeUnit.MILLISECONDS).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe\n");
            }

            @Override
            public void onNext(Integer integer) {
                mTvLog.append("onNext 接收到:"+integer+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete\n");
                Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }
        });



日志：


    onSubscribe
    Observable 发射1 睡490毫秒
    Observable 发射2 睡500毫秒
    onNext 接收到:2
    Observalbe 发射3 睡510毫秒
    onNext 接收到:3
    Observalbe 发射3 睡520毫秒
    onNext 接收到:4
    onComplete



19.defer


作用：defer 操作符与create、just、from等操作符一样，是创建类操作符，不过所有与该操作符相关的数据都是在订阅是才生效的。在某些情况下，等到最后一刻（即直到订阅时间）生成Observable可以确保此Observable包含最新的数据.


  Observable observableDefer = Observable.defer(new Callable>() {
            @Override
            public ObservableSource call() throws Exception {
                mTvLog.append("defer\n");
                return Observable.just(1);
            }
        });
        Observer observerDefer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("onSubscribe\n");
            }

            @Override
            public void onNext(Integer value) {
                mTvLog.append("onNext 接收到："+value+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("onComplete\n");
                Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
            }
        };

        observableDefer.subscribe(observerDefer);




日志：


    defer
    onSubscribe
    onNext 接收到：1
    onComplete



20.last


作用：接收发射的最后一个值，参数是没有值的时候的默认值


  Observable.just(1,2,3,4,5,6).last(0)
                .subscribe(new SingleObserver() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onSuccess(Integer integer) {
                        mTvLog.append("onSuccess 成功接收:"+integer+"\n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }
                });



日志：


    onSubscribe
    onSuccess 成功接收:6



21.merge


作用：把多个 Observable 结合起来，接受可变参数，也支持迭代器集合。注意它和 concat 的区别在于，不用等到 发射器 A 发送完所有的事件再进行发射器 B 的发送，两个发射器不再同一线程。


 @Override
    protected void test() {
        mTvLog.append("\n\n");

        Observable.merge(getObservable_1(), getObservable_2())
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(String value) {
                        mainThreadTextLog("onNext = " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                    }
                });
    }

    /**
     * 第一个Observable
     *
     * @return
     */
    private Observable getObservable_1() {
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {

                Thread.sleep(500);
                mainThreadTextLog("Observable_1发射 a");
                emitter.onNext("a");


                Thread.sleep(500);
                mainThreadTextLog("Observable_1发射 b");
                emitter.onNext("b");


                Thread.sleep(500);
                mainThreadTextLog("Observable_1发射 c");
                emitter.onNext("c");

                emitter.onComplete();

            }
        }).subscribeOn(Schedulers.io());
    }

    /**
     * 第二个Observable
     *
     * @return
     */
    private Observable getObservable_2() {
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                Thread.sleep(300);
                mainThreadTextLog("Observable_2发射 A");
                emitter.onNext("A");


                Thread.sleep(300);
                mainThreadTextLog("Observable_2发射 B");
                emitter.onNext("B");


                Thread.sleep(300);
                mainThreadTextLog("Observable_2发射 C");
                emitter.onNext("C");


                emitter.onComplete();

            }
        }).subscribeOn(Schedulers.io());
    }




日志：


    Observable_2发射 A
    onNext = A
    Observable_1发射 a
    onNext = a
    Observable_2发射 B
    onNext = B
    Observable_2发射 C
    onNext = C
    Observable_1发射 b
    onNext = b



22.reduce


作用：把一个被观察者中的多个事件进行压缩，最后发射压缩后的事件。聚合或压缩。


Observable.just(1,2,3,4)
                .reduce(new BiFunction() {
                    @Override
                    public Integer apply(Integer sum, Integer integer) throws Exception {
                        mTvLog.append("reduce sum:"+sum+"  integer:"+integer+"\n");
                        return sum+ integer;
                    }
                })
                .subscribe(new MaybeObserver() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onSuccess(Integer integer) {
                        mTvLog.append("onSuccess 接收到:"+integer+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });



日志：


    onSubscribe
    reduce sum:1  integer:2
    reduce sum:3  integer:3
    reduce sum:6  integer:4
    onSuccess 接收到:10



23.scan


作用：对发射的数据进行处理，发送每次的处理结果. reduce是对发射的数据进行处理，返回最终的处理结果。


 Observable.just(1,2,3,4)
                .scan(new BiFunction() {
                    @Override
                    public Integer apply(Integer sum, Integer integer) throws Exception {
                        mTvLog.append("sacn sum:"+sum+"  integer:"+integer+"\n");
                        return sum+ integer;
                    }
                })
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        mTvLog.append("onNext 接收到:"+integer+"\n");

                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });



日志：


    onSubscribe
    onNext 接收到:1
    scan sum:1  integer:2
    onNext 接收到:3
    scan sum:3  integer:3
    onNext 接收到:6
    scan sum:6  integer:4
    onNext 接收到:10
    onComplete




24.window


作用：有点类似buffer,window是把数据分割成了Observable，buffer是把数据分割成List


 mTvLog.append("Observable 发射 1，2，3，4，5\n");
        Observable.just(1,2,3,4,5)
                .window(3,2)
                .subscribe(new Observer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mTvLog.append("onSubscribe\n");
                    }

                    @Override
                    public void onNext(Observable integerObservable) {
                        mTvLog.append("onNext    "+integerObservable.toString()+"\n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvLog.append("onError\n");
                    }

                    @Override
                    public void onComplete() {
                        mTvLog.append("onComplete\n");
                        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());
                    }
                });



日志：


    Observable 发射 1，2，3，4，5
    onSubscribe
    onNext    io.reactivex.subjects.UnicastSubject@4a78b884
    onNext    io.reactivex.subjects.UnicastSubject@4a7b00fc
    onNext    io.reactivex.subjects.UnicastSubject@4a79b990
    onComplete



25.PublishSubject


作用：一旦订阅了，将所有随后观察到的项发送给订阅方。


 PublishSubject publishSubject = PublishSubject.create();

        //绑定第一个订阅者
        publishSubject.subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("第1个订阅者  onSubscribe\n");
            }

            @Override
            public void onNext(Integer value) {
                mTvLog.append("第1个订阅者  onNext 接收到："+value+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("第1个订阅者  onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("第1个订阅者  onComplete\n");
            }
        });

        //发射数据
        publishSubject.onNext(1);
        publishSubject.onNext(2);

        mTvLog.append(" - - - - \n");

        //绑定第二个订阅者
        publishSubject.subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("第2个订阅者  onSubscribe\n");
            }

            @Override
            public void onNext(Integer value) {
                mTvLog.append("第2个订阅者  onNext 接收到："+value+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("第2个订阅者  onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("第2个订阅者  onComplete\n");
            }
        });

        //发射数据
        publishSubject.onNext(3);
        publishSubject.onNext(4);
        publishSubject.onComplete();



日志：


    第1个订阅者  onSubscribe
    第1个订阅者  onNext 接收到：1
    第1个订阅者  onNext 接收到：2
     - - - - 
    第2个订阅者  onSubscribe
    第1个订阅者  onNext 接收到：3
    第2个订阅者  onNext 接收到：3
    第1个订阅者  onNext 接收到：4
    第2个订阅者  onNext 接收到：4
    第1个订阅者  onComplete
    第2个订阅者  onComplete



26.AsyncSubject


作用：在调用 onComplete() 之前，除了 subscribe() 其它的操作都会被缓存，在调用 onComplete() 之后只有最后一个 onNext() 会生效。


 AsyncSubject asyncSubject = AsyncSubject.create();

        //第一个订阅者
        asyncSubject.subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("第1个订阅者  onSubscirbe\n");
            }

            @Override
            public void onNext(Integer integer) {
                mTvLog.append("第1个订阅者  onNext  value:"+integer+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("第1个订阅者  onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("第1个订阅者  onComplete\n");
            }
        });

        asyncSubject.onNext(1);
        asyncSubject.onNext(2);
        asyncSubject.onComplete();

        mTvLog.append(" - - - \n");

        //第2个订阅者
        asyncSubject.subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mTvLog.append("第2个订阅者  onSubscirbe\n");
            }

            @Override
            public void onNext(Integer integer) {
                mTvLog.append("第2个订阅者  onNext  value:"+integer+"\n");
            }

            @Override
            public void onError(Throwable e) {
                mTvLog.append("第2个订阅者  onError\n");
            }

            @Override
            public void onComplete() {
                mTvLog.append("第2个订阅者  onComplete\n");
            }
        });

        asyncSubject.onNext(3);
        asyncSubject.onNext(4);
        asyncSubject.onComplete();



日志：


    第1个订阅者  onSubscirbe
    第1个订阅者  onNext  value:2
    第1个订阅者  onComplete
     - - - 
    第2个订阅者  onSubscirbe
    第2个订阅者  onNext  value:2
    第2个订阅者  onComplete



    

  • asyncSubject调用了onComplete后，后面的操作就不再生效。
    • 



27.BehaviorSubject


作用：发射Observable最近的数据，如果Observable还没有开始发射数据，则发射BehaviorSubject的默认数据


 BehaviorSubject behaviorSubject = BehaviorSubject.create();

        behaviorSubject.onNext(1);
        behaviorSubject.onNext(2);
        behaviorSubject.onNext(3);
        behaviorSubject.onNext(4);

        behaviorSubject.subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                mTvLog.append("accept 接收到value:"+integer+"\n");

            }
        });


        behaviorSubject.onNext(5);
        behaviorSubject.onNext(6);

        Log.i(mActivity.getClass().getSimpleName(),mTvLog.getText().toString());



日志:


    accept 接收到value:4
    accept 接收到value:5
    accept 接收到value:6




    

  • 发射的是订阅前发射的最后一个事件，加上订阅之后发射的所有事件
    • 



28.Flowable


作用：支持背压。背压指在异步场景中，被观察者发送事件的速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。


    

  • 背压：当上下游在不同的线程中，通过Observable发射，处理，响应数据流时，如果上游发射数据的速度快于下游接收处理数据的速度，这样对于那些没来得及处理的数据就会造成积压，这些数据既不会丢失，也不会被垃圾回收机制回收，而是存放在一个异步缓存池中，如果缓存池中的数据一直得不到处理，越积越多，最后就会造成内存溢出，这便是响应式编程中的背压（backpressure）问题。
    • 



  /**
     * 展示背压
     */
    private void showBackpressure(){
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                int i = 0;
                while (true){
                    i++;
                    e.onNext(i);
                }
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Thread.sleep(5000);
                        Log.e("accept","接收到 " + integer);
                    }
                });
    }



    

  • 上面的例子代码，由于上游通过Observable发射数据的速度大于下游通过Consumer接收处理数据的速度，而且上下游分别运行在不同的线程中，下游对数据的接收处理不会堵塞上游对数据的发射，造成上游数据积压，内存不断增加，最后便会导致内存溢出。
    • 

  • Subscription 用于响应式拉取。来设置下游对数据的请求数量，上游可以根据下游的需求量，按需发送数据。如果request设置下游的需求量为零，上游Flowable发射的数据不会交给下游Subscriber处理。
    • 



背压策略


    

  • BackpressureStrategy.MISSING:在此策略下，通过Create方法创建的Flowable相当于没有指定背压策略，不会对通过onNext发射的数据做缓存或丢弃处理，需要下游通过背压操作符
    • 

  • BackpressureStrategy.ERROR: 在此策略下，如果放入Flowable的异步缓存池中的数据超限了，则会抛出MissingBackpressureException异常
    • 

  • BackpressureStrategy.BUFFER:此策略下，如果Flowable默认的异步缓存池满了，会通过此缓存池暂存数据，它与Observable的异步缓存池一样，可以无限制向里添加数据，不会抛出MissingBackpressureException异常，但会导致OOM
    • 

  • BackpressureStrategy.DROP:在此策略下，如果Flowable的异步缓存池满了，会丢掉上游发送的数据
    • 

  • BackpressureStrategy.LATEST:Subscriber在接收完成之前，接收的数据是Flowable发射的最后一条数据
    • 



背压正确处理姿势


Flowable.create(new FlowableOnSubscribe() {
                    @Override
                    public void subscribe(FlowableEmitter e) throws Exception {
                        int i = 0;
                        while (true) {
                            if (e.requested() == 0) continue;//此处添加代码，让flowable按需发送数据
                            Log.e("Flowable","发射 --->"+i);
                            i++;
                            e.onNext(i);
                        }
                    }
                }, BackpressureStrategy.MISSING)
                .subscribeOn(Schedulers.newThread())
                .observeOn(Schedulers.newThread())
                .subscribe(new Subscriber() {
                    private Subscription mSubscription;

                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(1);            //设置初始请求数据量为1
                        mSubscription = s;
                    }

                    @Override
                    public void onNext(Integer integer) {
                        try {
                            Thread.sleep(50);
                            Log.e("Flowable","接收到 --->"+integer);
                            mSubscription.request(1);//每接收到一条数据增加一条请求量
                        } catch (InterruptedException ignore) {
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                    }

                    @Override
                    public void onComplete() {
                    }
                });


























你可能感兴趣的:(RxJava2操作符篇)






    

  • c++ 的iostream 和 c++的stdio的区别和联系
黄卷青灯77
c++算法开发语言iostreamstdio

    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    

    • 

  • 那个抄袭的大张伟
猫小努

    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    

    • 

  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
成长时间线

    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    

    • 

  • 直返最高等级与直返APP：无需邀请码的返利新体验
古楼

    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    

    • 

  • 高端密码学院笔记285
柚子_b4b4

    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    

    • 

  • python是什么意思中文-在python中%是什么意思
编程大乐趣

    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
    

    • 

  • 想明白这个问题，你才能写下去
文自拾

    春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
    

    • 

  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
高省APP珊珊

    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    

    • 

  • Python 实现图片裁剪（附代码） | Python工具
剑客阿良_ALiang

    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    

    • 

  • Redis系列：Geo 类型赋能亿级地图位置计算
Ly768768
redisbootstrap数据库

    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    

    • 

  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。
那一叶秋

    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
    

    • 

  • 【六】阿伟开始搭建Kafka学习环境
能源恒观
中间件学习kafkaspring

    阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
    

    • 

  • 戴先华2021.4.18《我的第129篇幸运作业》
39f4298779c4

    2021.4.18今天小宝和大表姐出去玩，我和婆婆在烧饭，突然小宝冲了进来，告诉奶奶说：“奶奶，奶奶姐姐在亭子里倒了”我一下子看出小宝的紧张，马上跑了出去，发现大外甥女又患了病，看起来心疼极了，整个人面朝地下的倒下了，在地上不停的抽搐，额头摔了一个大泡，整张脸都是紫色的，眼睛边上都出血了，真的是非常紧张，这么多年姐姐两夫妻就这样看着自己的孩子一次次晕倒，姐夫这么多年，年年都拿不出钱回家，使得家一次
    

    • 

  • 我与《红楼梦》‖纪念曹雪芹出生307周年！归海逸舟是周成功子阳佳乐
归海逸舟是周成功子阳佳乐

    【今日作家推荐】中国古典小说之首《红楼梦》，其作者曹雪芹是文坛泰斗。约1715年5月28日，曹雪芹出生。所以，今天推荐的是中国人众所周知的作家——曹雪芹。曹雪芹在世界读者心目中也影响广大，可以与西方世界引以为豪的莎士比亚、歌德等媲美。1、我与《红楼梦》我一直想写一篇和《红楼梦》相关的文章，现在机会终于来了！《红楼梦》作为我国家喻户晓的文学名著，其影响是空前的。还在我很小的时候，姥姥经常讲《红楼梦》
    

    • 

  • 白骑士的Java教学基础篇 2.5 控制流语句
白骑士所长
Java教学java开发语言

    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    

    • 

  • 系统架构设计师 需求分析篇二
AmHardy
软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML

    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
    

    • 

  • 手机上有什么兼职可以做？网上兼职 一单一结 手机就可以做？
优惠券高省

    建议上班族和全职宝妈把空闲时间拿出来一点做做副业，什么也不耽搁还能多一笔收入！推荐大家一定要试一试！！！只要有手机就可以做，下面小编就为大家推荐用手机就可以做的三类网上兼职工作。一，高省APP高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。万方导师高省邀请码005500，注册送双皇冠会员，送万元推广大礼包，教你如
    

    • 

  • 2023-06-19【感恩日记】第246篇
o泡沫o

    思想日记：坚持下去，相信自己一定可以的【感恩日记】第246篇1.我真是太幸福啦！感恩孩子早起阅读，放学到学生之家完成作业，平安度过美好的一天。感恩！感恩！感恩！❤️2.我真是太幸福啦！感恩自己早起给孩子煮早餐，完成计划的工作，晚上学习。感恩！感恩！感恩！❤️3.我真是太幸福啦！感恩为我设计效果图的老师。感恩！感恩！感恩！❤️4.我真是太幸福啦！感恩父母养育了我，有妈的孩子真幸福。感恩！感恩！感恩！
    

    • 

  • 摄影小白，怎么才能拍出高大上产品图片？
是波妞唉

    很多人以为文案只要会码字，会排版就OK了！说实话，没接触到这一行的时候，我的想法更简单，以为只要会写字就行！可是真做了文案才发现，码字只是入门级的基本功。一篇文章离不开排版、配图，说起来很简单！从头做到尾你就会发现，写文章用两个小时，找合适的配图居然要花掉半天的时间，甚至更久！图片能找到合适的就不怕，还有找不到的，比如产品图，只能亲自拍。拿着摆弄了半天，就是拍不出想要的效果，光线不好、搭出来丑破天
    

    • 

  • 【创客文案社】第三期写手招募
筱瑶123

    创客文案社第三期写手招募开始了。要求：1：注册一个月以上2：本身热爱写作3：有时间参与接单投稿参与方式：可以关注公众号：写作灵感；也可以通过其他转发文章的文友帮忙拉入群；也可以简信我。参与之后的文友，会先进入新人班，进行基本的试稿与培训，先接一些比较简单的单子；在这里可以一边赚钱，一边学习。不知不觉，来三四个月了，也发现了很多很有意思的现象。1：在上写一篇文章，基本都是几毛钱，多的也不过几块钱的收
    

    • 

  • [故旧之事]外婆记事(28)
石里夜人

    二十七．破四旧本来是庆祝儿童节的日子，因为报纸的一篇文章，让很多家庭陷入了惶恐之中。为了响应这项旨在“破除旧思想、旧文化、旧风俗、旧习惯”的群众运动，街道里的干部给大家开了会，做了总动员，要求大家首先自省，从身边的人开始，自纠自查。院里的街坊们回到家，转悠了一圈，发现并没有什么可做的。这几条街家家都很穷。有的人翻了家里的书，除了把孩子的课本留着，找到仅有的几本旧书，一把火塞进了炉膛里。有的人检查了
    

    • 

  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT

    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    

    • 

  • 阅读笔记：阅读方法中的逻辑和转念
施吉涛

    聊聊一些阅读的方法论吧，别人家的读书方法刚开始想写，然后就不知道写什么了，因为作者写的非常的“精致”我有一种乡巴佬进城的感觉，看到精美的摆盘，精致的食材不知道该如何下口也就是《阅读的方法》，我们姑且来试一下强劲的大脑篇，第一节：逻辑通俗的来讲，也就是表达的排列和顺序，再进一步就是因果关系和关联实际上书已经看了大概一遍，但直到打算写一下笔记的时候，才发现作者讲的推理更多的是阅读的对象中呈现出的逻辑也
    

    • 

  • 每天赚50零花钱的方法，日赚50元左右的5个正规渠道
一起高省

    每个人都希望拥有一笔自己的零花钱，但是很多人可能没有太多的时间去赚钱，或者没有太多的机会去赚取收入。但是，你可以通过一些简单的方法来赚取每天50元的零花钱。下面分享一些能每天赚50元的方法门路，总有一个适合你！①电商——高省高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。拂晓导师高省邀请码989898，注册送双皇
    

    • 

  • 阿里云服务器4核8G配置购买及价格类文章汇总（10篇）
阿里云最新优惠和活动汇总

    阿里云服务器4核8G配置如何购买？价格是多少？4核8G配置的阿里云服务器可以通过云服务器产品页购买也可以通过阿里云活动去下单购买，一般通过活动购买的用户比较多，但是不同实例规格的阿里云服务器价格不一样，带宽不同价格也不一样，本文为大家汇总了10篇关于阿里云服务器4核8G配置购买教程文章和价格类文章，分为购买类文章和价格类文章，以供大家参考如何购买阿里云服务器4核8G配置和最新优惠价格是多少。阿里云
    

    • 

  • 拼多多返现要输入身份证号码安全吗?拼单返现是什么?
优惠券高省

    当我们谈到拼多多返现金活动时，很多朋友会担心提供身份证信息的安全性以及返现金额的真实性。今天，我就来为大家揭开这些疑虑的面纱，为大家提供一个清晰的答案。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。高省是公认的返利最高的软件。古楼导师
    

    • 

  • 自动写论文的网站推荐这5款实用类工具
小猪包333
写论文人工智能深度学习计算机视觉AI写作

    在当今学术研究和写作领域，AI论文写作工具的出现极大地提高了写作效率和质量。这些工具不仅能够帮助研究人员快速生成论文草稿，还能进行内容优化、查重和排版等操作。以下是五款实用类工具推荐，特别是千笔-AIPassPaper。1.千笔-AIPassPaper千笔-AIPassPaper是一款功能强大且全面的AI论文写作助手，用户只需输入基本的研究需求和关键词，便能迅速生成一篇完整的论文。该工具利用先进的
    

    • 

  • 酒店床装车出货
臧冰

    一百多套的酒店床、圆床，床垫终于出货了，可惜还没装完，明天将继续出货，辛苦了各位小伙伴们！图片发自App图片发自App图片发自App图片发自App图片发自App图片发自App图片发自App图片发自App我是两个孩子的宝妈，经营着一间软体家具厂，“伊力威斯”是我们的品牌。这是我的第178篇原创日记。栽一棵树最好的时间是十年前跟今天，写日记亦是如此，抓住今天，我们将收获更精彩的人生！
    

    • 

  • 毕业论文附录一般都写什么?大学生写论文是干嘛用的
写个原创论文
人工智能深度学习AI写作chatgpt论文阅读

    毕业论文的附录通常包含一些在正文中不便于展示或详细阐述的内容，但对理解论文整体又具有重要意义的资料。具体来说，附录可能包含以下内容：AI论文，免费大纲，10分钟3万字，查重高于15%退费，支持数据图表！！AIPaperPass-AI论文写作指导平台AIPaperPass是AI原创论文写作平台，免费千字大纲，5分钟生成3万字初稿，提供答辩汇报ppt、开题报告、任务书等，40篇真实中英文知网参考文献，
    

    • 

  • 7号卢秀梅《给教师的建议》第6篇读后感
星辰85

    思考中获得活的知识一一《知识既是目的又是手段》读后感学生掌握的知识越多，学习就应该越省劲。可惜实际情况往往相反:总有些学生的学习一年比一年困难。苏霍姆林斯基在《知识既是目的又是手段》一文中分析说:知识对有些学生来说成了滞销的货物，得不到运用。知识似乎与学生的精神生活和智力兴趣不相干。掌握知识对学生来说变成了讨厌的事，学生没有了兴趣，更缺乏思考。我们教师要努力使学生把获得知识不当成最终目的，而当成一
    

    • 

  • github中多个平台共存
jackyrong
github

    在个人电脑上，如何分别链接比如oschina,github等库呢，一般教程之列的，默认
ssh链接一个托管的而已，下面讲解如何放两个文件
1） 设置用户名和邮件地址
$ git config --global user.name "xx"
$ git config --global user.email "[email protected]"
    

    • 

  • ip地址与整数的相互转换(javascript)
alxw4616
JavaScript

    //IP转成整型
function ip2int(ip){
var num = 0;
ip = ip.split(".");
num = Number(ip[0]) * 256 * 256 * 256 + Number(ip[1]) * 256 * 256 + Number(ip[2]) * 256 + Number(ip[3]);
n
    

    • 

  • 读书笔记-jquey+数据库+css
chengxuyuancsdn
htmljqueryoracle

    1、grouping ,group by rollup, GROUP BY GROUPING SETS区别
2、$("#totalTable tbody>tr td:nth-child(" + i + ")").css({"width":tdWidth, "margin":"0px", &q
    

    • 

  • javaSE javaEE javaME == API下载
Array_06
java

    oracle下载各种API文档：
http://www.oracle.com/technetwork/java/embedded/javame/embed-me/documentation/javame-embedded-apis-2181154.html
JavaSE文档：
http://docs.oracle.com/javase/8/docs/api/
JavaEE文档：
ht
    

    • 

  • shiro入门学习
cugfy
javaWeb框架

    声明本文只适合初学者，本人也是刚接触而已，经过一段时间的研究小有收获，特来分享下希望和大家互相交流学习。
首先配置我们的web.xml代码如下，固定格式，记死就成
<filter>
        <filter-name>shiroFilter</filter-name>
&nbs
    

    • 

  • Array添加删除方法
357029540
js

         刚才做项目前台删除数组的固定下标值时，删除得不是很完整，所以在网上查了下，发现一个不错的方法，也提供给需要的同学。
//给数组添加删除
            Array.prototype.del = function(n){

    

    • 

  • navigation bar 更改颜色
张亚雄
IO

    今天郁闷了一下午，就因为objective-c默认语言是英文，我写的中文全是一些乱七八糟的样子，到不是乱码，但是，前两个自字是粗体，后两个字正常体，这可郁闷死我了，问了问大牛，人家告诉我说更改一下字体就好啦，比如改成黑体，哇塞，茅塞顿开。
      翻书看，发现，书上有介绍怎么更改表格中文字字体的，代码如下
   
    

    • 

  • unicode转换成中文
adminjun
unicode编码转换

     
在Java程序中总会出现\u6b22\u8fce\u63d0\u4ea4\u5fae\u535a\u641c\u7d22\u4f7f\u7528\u53cd\u9988\uff0c\u8bf7\u76f4\u63a5这个的字符，这是unicode编码，使用时有时候不会自动转换成中文就需要自己转换了使用下面的方法转换一下即可。
/**
* unicode 转换成 中文

    

    • 

  • 一站式 Java Web 框架 firefly
aijuans
Java Web

    Firefly是一个高性能一站式Web框架。 涵盖了web开发的主要技术栈。 包含Template engine、IOC、MVC framework、HTTP Server、Common tools、Log、Json parser等模块。
firefly-2.0_07修复了模版压缩对javascript单行注释的影响，并新增了自定义错误页面功能。
更新日志：
增加自定义系统错误页面功能
    

    • 

  • 设计模式——单例模式
ayaoxinchao
设计模式

    定义
 
       Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”
 
分析
 
       从定义中可以看出单例的要点有三个：一是某个类只能有一个实例；二是必须自行创建这个实例；三是必须自行向系统提供这个实例。
  &nb
    

    • 

  • Javascript 多浏览器兼容性问题及解决方案
BigBird2012
JavaScript

    不论是网站应用还是学习js,大家很注重ie与firefox等浏览器的兼容性问题，毕竟这两中浏览器是占了绝大多数。
一、document.formName.item(”itemName”) 问题
问题说明：IE下，可以使用 document.formName.item(”itemName”) 或 document.formName.elements ["elementName&quo
    

    • 

  • JUnit-4.11使用报java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing错误
bijian1013
junit4.11单元测试

            下载了最新的JUnit版本，是4.11，结果尝试使用发现总是报java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing这样的错误，上网查了一下，一般的解决方案是，换一个低一点的版本就好了。还有人说，是缺少hamcrest的包。去官网看了一下，如下发现：
   
    

    • 

  • [Zookeeper学习笔记之二]Zookeeper部署脚本
bit1129
zookeeper

    Zookeeper伪分布式安装脚本(此脚本在一台机器上创建Zookeeper三个进程，即创建具有三个节点的Zookeeper集群。这个脚本和zookeeper的tar包放在同一个目录下，脚本中指定的名字是zookeeper的3.4.6版本，需要根据实际情况修改)：
 
#!/bin/bash
#!!!Change the name!!!
#The zookeepe
    

    • 

  • 【Spark八十】Spark RDD API二
bit1129
spark

    coGroup
package spark.examples.rddapi
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.SparkContext._
object CoGroupTest_05 {
def main(args: Array[String]) {
v
    

    • 

  • Linux中编译apache服务器modules文件夹缺少模块(.so)的问题
ronin47
modules

    在modules目录中只有httpd.exp，那些so文件呢？
我尝试在fedora core 3中安装apache 2. 当我解压了apache 2.0.54后使用configure工具并且加入了 --enable-so 或者 --enable-modules=so (两个我都试过了)
去make并且make install了。我希望在/apache2/modules/目录里有各种模块，
    

    • 

  • Java基础-克隆
BrokenDreams
java基础

            Java中怎么拷贝一个对象呢？可以通过调用这个对象类型的构造器构造一个新对象，然后将要拷贝对象的属性设置到新对象里面。Java中也有另一种不通过构造器来拷贝对象的方式，这种方式称为
克隆。
        Java提供了java.lang.
    

    • 

  • 读《研磨设计模式》-代码笔记-适配器模式-Adapter
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
package design.pattern;
/*
* 适配器模式解决的主要问题是，现有的方法接口与客户要求的方法接口不一致
* 可以这样想，我们要写这样一个类（Adapter）:
* 1.这个类要符合客户的要求 ---> 那显然要
    

    • 

  • HDR图像PS教程集锦&心得
cherishLC
PS

    HDR是指高动态范围的图像，主要原理为提高图像的局部对比度。
软件有photomatix和nik hdr efex。
一、教程
叶明在知乎上的回答：
http://www.zhihu.com/question/27418267/answer/37317792
大意是修完后直方图最好是等值直方图，方法是HDR软件调一遍，再结合不透明度和蒙版细调。
二、心得
1、去除阴影部分的
    

    • 

  • maven-3.3.3 mvn archetype 列表
crabdave
ArcheType

    maven-3.3.3 mvn archetype 列表
可以参考最新的：http://repo1.maven.org/maven2/archetype-catalog.xml
 
[INFO] Scanning for projects...
[INFO]                 
    

    • 

  • linux shell 中文件编码查看及转换方法
daizj
shell中文乱码vim文件编码

    一、查看文件编码。
    在打开文件的时候输入:set fileencoding
    即可显示文件编码格式。
二、文件编码转换
    1、在Vim中直接进行转换文件编码,比如将一个文件转换成utf-8格式
      &
    

    • 

  • MySQL--binlog日志恢复数据
dcj3sjt126com
binlog

     恢复数据的重要命令如下 mysql> flush logs; 默认的日志是mysql-bin.000001，现在刷新了重新开启一个就多了一个mysql-bin.000002                  
    

    • 

  • 数据库中数据表数据迁移方法
dcj3sjt126com
sql

    刚开始想想好像挺麻烦的，后来找到一种方法了，就SQL中的 INSERT 语句，不过内容是现从另外的表中查出来的，其实就是 MySQL中INSERT INTO SELECT的使用
 
下面看看如何使用
 
语法：MySQL中INSERT INTO SELECT的使用
1. 语法介绍
      有三张表a、b、c，现在需要从表b
    

    • 

  • Java反转字符串
dyy_gusi
java反转字符串

           前几天看见一篇文章，说使用Java能用几种方式反转一个字符串。首先要明白什么叫反转字符串，就是将一个字符串到过来啦，比如"倒过来念的是小狗"反转过来就是”狗小是的念来过倒“。接下来就把自己能想到的所有方式记录下来了。
1、第一个念头就是直接使用String类的反转方法，对不起，这样是不行的，因为Stri
    

    • 

  • UI设计中我们为什么需要设计动效
gcq511120594
UIlinux

    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。
但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。
一、加强体验舒适度
嗯，就是让用户更加爽更加爽的用
    

    • 

  • JBOSS服务部署端口冲突问题
HogwartsRow
java应用服务器jbossserverEJB3

    服务端口冲突问题的解决方法，一般修改如下三个文件中的部分端口就可以了。
 
1、jboss5/server/default/conf/bindingservice.beans/META-INF/bindings-jboss-beans.xml
 
2、./server/default/deploy/jbossweb.sar/server.xml
 
3、.
    

    • 

  • 第三章 Redis/SSDB+Twemproxy安装与使用
jinnianshilongnian
ssdbreidstwemproxy

    目前对于互联网公司不使用Redis的很少，Redis不仅仅可以作为key-value缓存，而且提供了丰富的数据结果如set、list、map等，可以实现很多复杂的功能；但是Redis本身主要用作内存缓存，不适合做持久化存储，因此目前有如SSDB、ARDB等，还有如京东的JIMDB，它们都支持Redis协议，可以支持Redis客户端直接访问；而这些持久化存储大多数使用了如LevelDB、RocksD
    

    • 

  • ZooKeeper原理及使用 
liyonghui160com

     
 
       ZooKeeper是Hadoop Ecosystem中非常重要的组件，它的主要功能是为分布式系统提供一致性协调(Coordination)服务，与之对应的Google的类似服务叫Chubby。今天这篇文章分为三个部分来介绍ZooKeeper，第一部分介绍ZooKeeper的基本原理，第二部分介绍ZooKeeper
    

    • 

  • 程序员解决问题的60个策略
pda158
框架工作单元测试

    根本的指导方针
1. 首先写代码的时候最好不要有缺陷。最好的修复方法就是让 bug 胎死腹中。
良好的单元测试
强制数据库约束
使用输入验证框架
避免未实现的“else”条件
在应用到主程序之前知道如何在孤立的情况下使用
 
日志
2. print 语句。往往额外输出个一两行将有助于隔离问题。
3. 切换至详细的日志记录。详细的日
    

    • 

  • Create the Google Play Account
sillycat
Google

    Create the Google Play Account
Having a Google account, pay 25$, then you get your google developer account.
References:
http://developer.android.com/distribute/googleplay/start.html
https://p
    

    • 

  • JSP三大指令
vikingwei
jsp

    JSP三大指令
  一个jsp页面中，可以有0~N个指令的定义！
1. page --> 最复杂：<%@page language="java" info="xxx"...%>
  * pageEncoding和contentType：
    > pageEncoding：它
    

    •