谢尔顿
谢尔顿

RxJava操作符--->功能性操作符

引言

该篇文章主要是关于RxJava的功能性操作符使用的代码讲解。功能性操作符总共以下几类：

  • 连接被观察&观察者：subscribe()
  • 线程调度：subscribeOn()，observeOn()
  • 延迟操作：delay()
  • 在事件的生命周期中操作：do
  • 错误处理：onErrorReturn，onErrorResumeNext，onExceptionResumeNext，retry，retryUntil，retryWhen
  • 重复发送操作：repeat，repeatWhen()

1. subscribe()

        /**
         * 1.分步骤的完整调用
         */
        //步骤1：创建被观察者 Observable 对象
        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        });
        //步骤2：创建观察者Observer 并定义响应事件行为
        Observer observer = new Observer() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(Constant.TAG,"开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG,"对Next事件"+value +"做出响应");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG,"对Error事件做出响应");
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG,"对complete事件做出响应");
            }
        };

        //步骤3：通过订阅连接观察者和被观察者
        observable.subscribe(observer);

        /**
         * 2.基于事件流的链式调用
         */
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(Constant.TAG,"开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG,"对Next事件"+value +"做出响应");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG,"对Error事件做出响应");
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG,"对complete事件做出响应");
            }
        });

log信息：

06-26 18:04:26.267 9000-9000/com.gjj.frame D/RxJava: 开始采用subscribe连接
06-26 18:04:26.267 9000-9000/com.gjj.frame D/RxJava: 对Next事件1做出响应
06-26 18:04:26.267 9000-9000/com.gjj.frame D/RxJava: 对Next事件2做出响应
06-26 18:04:26.267 9000-9000/com.gjj.frame D/RxJava: 对Next事件3做出响应
06-26 18:04:26.268 9000-9000/com.gjj.frame D/RxJava: 对complete事件做出响应

2.线程调度

指定被观察者和观察者的工作线程，详见文章RxJava操作符--->线程调度

3.delay()

使得被观察者延迟一段时间再发送事件。
delay()有多个重载方法：

// 1. 指定延迟时间
// 参数1 = 时间；参数2 = 时间单位
delay(long delay,TimeUnit unit)

// 2. 指定延迟时间 & 调度器
// 参数1 = 时间；参数2 = 时间单位；参数3 = 线程调度器
delay(long delay,TimeUnit unit,mScheduler scheduler)

// 3. 指定延迟时间  & 错误延迟
// 错误延迟，即：若存在Error事件，则如常执行，执行后再抛出错误异常
// 参数1 = 时间；参数2 = 时间单位；参数3 = 错误延迟参数
delay(long delay,TimeUnit unit,boolean delayError)

// 4. 指定延迟时间 & 调度器 & 错误延迟
// 参数1 = 时间；参数2 = 时间单位；参数3 = 线程调度器；参数4 = 错误延迟参数
delay(long delay,TimeUnit unit,mScheduler scheduler,boolean delayError): 指定延迟多长时间并添加调度器，错误通知可以设置是否延迟

使用：

        Observable.just(1,2,3)
                .delay(3, TimeUnit.SECONDS)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(Constant.TAG,"接收到了事件"+integer);
                    }
                });

log信息：

06-27 13:37:29.114 907-971/com.gjj.frame D/RxJava: 接收到了事件1
06-27 13:37:29.116 907-971/com.gjj.frame D/RxJava: 接收到了事件2
06-27 13:37:29.117 907-971/com.gjj.frame D/RxJava: 接收到了事件3
06-27 13:37:29.118 907-971/com.gjj.frame D/RxJava: 对Complete事件作出响应

4. do()

在某个事件的生命周期中调用，具体有如下分类：

  • 当Observable每发送1次数据事件就会调用1次，doOnEach()
  • 执行Next事件前调用，doOnNext()
  • 执行Next事件后调用，doAfterNext()
  • 发送错误事件时调用，doOnError()
  • 正常发送事件完毕后调用，doOnCompelted()
  • 无论正常发送完毕/异常终止时调用，doOnTerminate()
  • 观察者订阅时调用，doOnSubscribe()
  • 观察者取消订阅时调用，doOnUnsubscribe()

使用：

        Observable.create(new ObservableOnSubscribe()   {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);

                e.onError(new Throwable("发生错误了"));
            }
        }).doOnEach(new Consumer>() {
            @Override
            public void accept(Notification integerNotification) throws Exception {
                Log.d(Constant.TAG,"doOnEach:"+integerNotification.getValue());
            }
        }).doOnNext(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(Constant.TAG,"doOnNext："+integer);
            }
        }).doAfterNext(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(Constant.TAG,"doAfterNext:"+integer);
            }
        }).doOnComplete(new Action() {
            @Override
            public void run() throws Exception {
                Log.e(Constant.TAG,"doOnComplete()");
            }
        }).doOnError(new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.d(Constant.TAG,"doOnError:"+throwable.getMessage());
            }
        }).doOnSubscribe(new Consumer() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(Constant.TAG,"doOnSubscribe");
            }
        }).doFinally(new Action() {
            @Override
            public void run() throws Exception {
                Log.e(Constant.TAG,"doFinally");
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG,"接收到了事件"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG,"对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG,"对Complete事件作出响应");
            }
        });

log信息：

06-27 13:59:43.141 2617-2617/com.gjj.frame E/RxJava: doOnSubscribe
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doOnEach:1
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doOnNext：1
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: 接收到了事件1
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doAfterNext:1
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doOnEach:2
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doOnNext：2
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: 接收到了事件2
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doAfterNext:2
06-27 13:59:43.142 2617-2617/com.gjj.frame D/RxJava: doOnEach:null
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: doOnError:发生错误了
06-27 13:59:43.141 2617-2617/com.gjj.frame D/RxJava: 对Error事件作出响应
06-27 13:59:43.142 2617-2617/com.gjj.frame E/RxJava: doFinally

5. onErrorReturn()

在发送事件的过程中，遇到错误时，发送一个特殊事件&正常终止，可捕获在它之前发生的异常。
使用：

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Throwable("发生错误了"));
            }
        }).onErrorReturn(new Function() {
            @Override
            public Integer apply(Throwable throwable) throws Exception {
                //捕捉错误异常
                Log.e(Constant.TAG,"在OnErrorReturn处理了错误："+throwable.toString());
                return 666;
                //发生错误事件后，发送一个“666”事件，最终正常结束
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG,"接收到了事件"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG,"对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG,"对Complete事件作出响应");
            }
        });

log信息:

06-27 15:13:53.001 6782-6782/com.gjj.frame D/RxJava: 接收到了事件1
06-27 15:13:53.002 6782-6782/com.gjj.frame D/RxJava: 接收到了事件2
06-27 15:13:53.002 6782-6782/com.gjj.frame E/RxJava: 在OnErrorReturn处理了错误：java.lang.Throwable: 发生错误了
06-27 15:13:53.002 6782-6782/com.gjj.frame D/RxJava: 接收到了事件666
06-27 15:13:53.002 6782-6782/com.gjj.frame D/RxJava: 对Complete事件作出响应

6. onErrorResumeNext()

遇到错误时，发送1个新的Observable

注：

  1. onErrorResumeNext()拦截的错误 = Throwable;若需拦截Exception请用OnExceptionResumeNext()
    2.若onErrorResumeNext()拦截的错误 = Exception，则会将错误传递给观察者的onError方法

使用：

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(1);
                e.onError(new Throwable("发生错误了"));
            }
        }).onErrorResumeNext(new Function>() {
            @Override
            public ObservableSource apply(Throwable throwable) throws Exception {
                Log.e(Constant.TAG,"在onErrorReturn处理了错误："+throwable.toString());
                return Observable.just(11,22);
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG,"接受到了事件"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG,"对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG,"对Complete事件作出响应");
            }
        });

log信息：

06-27 15:24:05.667 7285-7285/com.gjj.frame D/RxJava: 接受到了事件1
06-27 15:24:05.667 7285-7285/com.gjj.frame D/RxJava: 接受到了事件1
06-27 15:24:05.667 7285-7285/com.gjj.frame E/RxJava: 在onErrorReturn处理了错误：java.lang.Throwable: 发生错误了
06-27 15:24:05.668 7285-7285/com.gjj.frame D/RxJava: 接受到了事件11
06-27 15:24:05.668 7285-7285/com.gjj.frame D/RxJava: 接受到了事件22
06-27 15:24:05.668 7285-7285/com.gjj.frame D/RxJava: 对Complete事件作出响应

7. onExceptionResumeNext()

遇到错误时，发送1个新的Observable

注：

  1. onExceptionResumeNext()拦截的错误 = Exception;若需拦截Throwable请用OnExceptionResumeNext()
    2.若onExceptionResumeNext()拦截的错误 = Throwable，则会将错误传递给观察者的onError方法

使用：

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(1);
                e.onError(new Exception("发生错误了"));
            }
        }).onExceptionResumeNext(new Observable() {
            @Override
            protected void subscribeActual(Observer observer) {
                observer.onNext(11);
                observer.onNext(22);
                observer.onComplete();
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG,"接受到了事件"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG,"对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG,"对Complete事件作出响应");
            }
        });

log信息：

06-27 15:30:30.618 7744-7744/com.gjj.frame D/RxJava: 接受到了事件1
06-27 15:30:30.618 7744-7744/com.gjj.frame D/RxJava: 接受到了事件1
06-27 15:30:30.618 7744-7744/com.gjj.frame D/RxJava: 接受到了事件11
06-27 15:30:30.619 7744-7744/com.gjj.frame D/RxJava: 接受到了事件22
06-27 15:30:30.618 7744-7744/com.gjj.frame D/RxJava: 对Complete事件作出响应

8. retry()

在发送事件的过程中，出现错误时，让被观察者Observable重新发射数据

1.接收到onError时，重新订阅&发送事件
2.Throwable和Exception都可拦截

retry()对应的有五种重载方法：

<-- 1. retry（） -->
// 作用：出现错误时，让被观察者重新发送数据
// 注：若一直错误，则一直重新发送

<-- 2. retry（long time） -->
// 作用：出现错误时，让被观察者重新发送数据（具备重试次数限制
// 参数 = 重试次数
 
<-- 3. retry（Predicate predicate） -->
// 作用：出现错误后，判断是否需要重新发送数据（若需要重新发送& 持续遇到错误，则持续重试）
// 参数 = 判断逻辑

<--  4. retry（new BiPredicate） -->
// 作用：出现错误后，判断是否需要重新发送数据（若需要重新发送 & 持续遇到错误，则持续重试
// 参数 =  判断逻辑（传入当前重试次数 & 异常错误信息）

<-- 5. retry（long time,Predicate predicate） -->
// 作用：出现错误后，判断是否需要重新发送数据（具备重试次数限制
// 参数 = 设置重试次数 & 判断逻辑
  • retry()
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onError(new Exception("发生错误了"));
                e.onNext(2);
            }
        }).retry()
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(Constant.TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(Constant.TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(Constant.TAG, "对Complete事件作出响应");
                    }

                });
  • retry(long time)
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onError(new Exception("发生错误了"));
                e.onNext(2);
            }
        }).retry(3)//重试次数
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(Constant.TAG,"接受到了事件"+integer);
                    }
                });
  • retry(Predicate predicate)
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onError(new Exception("发生错误了"));
                e.onNext(2);
            }
        }).retry(new Predicate() {
            @Override
            public boolean test(Throwable throwable) throws Exception {
                //捕获异常
                Log.d(Constant.TAG,"retry错误："+throwable.toString());
                //返回false = 不重新发送数据 & 调用观察者的onError结束
                //返回true = 重新发送请求（若持续遇到错误，就持续重新发送）
                return true;
            }
        })//重试次数
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(Constant.TAG,"接受到了事件"+integer);
                    }
                });
  • retry（new BiPredicate）
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onError(new Exception("发生错误了"));
                e.onNext(2);
            }
        }).retry(new BiPredicate() {
            @Override
            public boolean test(Integer integer, Throwable throwable) throws Exception {
                //捕获异常
                Log.d(Constant.TAG,"异常错误="+throwable.toString());
                //获取当前重试次数
                Log.e(Constant.TAG,"当前重试次数 = " +integer);
                return false;
            }
        })//重试次数
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(Constant.TAG,"接受到了事件"+integer);
                    }
                });
  • retry（long time,Predicate predicate）
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onError(new Exception("发生错误了"));
                e.onNext(2);
            }
        }).retry(3, new Predicate() {
            @Override
            public boolean test(Throwable throwable) throws Exception {
                Log.e(Constant.TAG,"retry错误："+throwable.toString());
                return true;
            }
        })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(Constant.TAG,"接受到了事件"+integer);
                    }
                });

9. retryUntil()

出现错误后，判断是否需要重新发送数据，作用类似于retry（Predicate predicate）。

10. retryWhen()

在发送事件的过程中遇到错误时，将发生的错误传递给一个新的被观察者，并决定是否需要重新订阅原始被观察者&发送数据
使用：

Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("发生错误了"));
                e.onNext(2);
            }
        })
                //遇到Error事件才会回调
                .retryWhen(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(Observable throwableObservable) throws Exception {
                // 参数Observable中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
                // 返回Observable = 新的被观察者 Observable（任意类型）
                // 此处有两种情况：
                // 1. 若 新的被观察者 Observable发送的事件 = Error事件，那么 原始Observable则不重新发送事件：
                // 2. 若 新的被观察者 Observable发送的事件 = Next事件 ，那么原始的Observable则重新发送事件：

                return throwableObservable.flatMap(new Function>() {
                    @Override
                    public ObservableSource apply(Throwable throwable) throws Exception {
                        // 1. 若返回的Observable发送的事件 = Error事件，则原始的Observable不重新发送事件
                        // 该异常错误信息可在观察者中的onError（）中获得
//                        return Observable.error(new Throwable("retryWhen终止了"));
                        // 2. 若返回的Observable发送的事件 = Next事件，则原始的Observable重新发送事件（若持续遇到错误，则持续重试）
                         return Observable.just(5);
                    }
                });
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }
            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG, "接收到了事件"+ value  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG, "对Error事件作出响应" + e.toString());
                // 获取异常错误信息
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG, "对Complete事件作出响应");
            }
        });
  • 新的Observable发送错误事件时，原始Observable终止发送
06-27 17:40:53.110 21606-21606/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:40:53.113 21606-21606/com.gjj.frame D/RxJava: 对Error事件作出响应java.lang.Throwable: retryWhen终止了
  • 新的Observable发送数据事件时，原始Observable持续重试
06-27 17:44:03.969 22791-22791/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:44:03.970 22791-22791/com.gjj.frame D/RxJava: 接收到了事件2
    接收到了事件1
06-27 17:44:03.971 22791-22791/com.gjj.frame D/RxJava: 接收到了事件2
06-27 17:44:03.970 22791-22791/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:44:03.971 22791-22791/com.gjj.frame D/RxJava: 接收到了事件2
06-27 17:44:03.970 22791-22791/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:44:03.970 22791-22791/com.gjj.frame D/RxJava: 接收到了事件2
06-27 17:44:03.972 22791-22791/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:44:03.970 22791-22791/com.gjj.frame D/RxJava: 接收到了事件2

11.repeat()

无条件地、重复发送被观察者事件
使用：

        //repeat();无限次发送
        //repeat(3);重复发送次数有限
        Observable.just(1,2)
                .repeat(3)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(Constant.TAG,"接收到了事件"+integer);
                    }
                });

log信息：

06-27 17:51:15.766 23209-23209/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:51:15.766 23209-23209/com.gjj.frame D/RxJava: 接收到了事件2
06-27 17:51:15.766 23209-23209/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:51:15.766 23209-23209/com.gjj.frame D/RxJava: 接收到了事件2
06-27 17:51:15.766 23209-23209/com.gjj.frame D/RxJava: 接收到了事件1
06-27 17:51:15.766 23209-23209/com.gjj.frame D/RxJava: 接收到了事件2

12.repeatWhen()

有条件地、重复发送被观察者事件，如果新观察者返回Complete/Error事件，则不重新发送原来的Observable，如果新观察者返回其余事件时，则重新发送原来的Observable。

使用：

        Observable.just(1,2)
                // 在Function函数中，必须对输入的 Observable进行处理，这里我们使用的是flatMap操作符接收上游的数据
                .repeatWhen(new Function, ObservableSource>() {
                    @Override
                    public ObservableSource apply(Observable objectObservable) throws Exception {

                        // 将原始 Observable 停止发送事件的标识（Complete（） /  Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable）
                        // 以此决定是否重新订阅 & 发送原来的 Observable
                        // 此处有2种情况：
                        // 1. 若新被观察者（Observable）返回1个Complete（） /  Error（）事件，则不重新订阅 & 发送原来的 Observable
                        // 2. 若新被观察者（Observable）返回其余事件，则重新订阅 & 发送原来的 Observable
                        return objectObservable.flatMap(new Function>() {
                            @Override
                            public ObservableSource apply(@NonNull Object throwable) throws Exception {

                                // 情况1：若新被观察者（Observable）返回1个Complete（） /  Error（）事件，则不重新订阅 & 发送原来的 Observable
                                return Observable.empty();
                                // Observable.empty() = 发送Complete事件，但不会回调观察者的onComplete（）

                                // return Observable.error(new Throwable("不再重新订阅事件"));
                                // 返回Error事件 = 回调onError（）事件，并接收传过去的错误信息。

                                // 情况2：若新被观察者（Observable）返回其余事件，则重新订阅 & 发送原来的 Observable
                                // return Observable.just(1);
                                // 仅仅是作为1个触发重新订阅被观察者的通知，发送的是什么数据并不重要，只要不是Complete（） /  Error（）事件
                            }
                        });

                    }
                }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(Constant.TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(Constant.TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(Constant.TAG, "对Error事件作出响应：" + e.toString());
            }

            @Override
            public void onComplete() {
                Log.d(Constant.TAG, "对Complete事件作出响应");
            }

        });


    

  • 新的Observable发送Complete事件 = 原始Observable停止发送&不重新发送
    • 



06-27 18:03:30.669 23471-23471/com.gjj.frame D/RxJava: 开始采用subscribe连接
06-27 18:03:30.674 23471-23471/com.gjj.frame D/RxJava: 接收到了事件1
06-27 18:03:30.674 23471-23471/com.gjj.frame D/RxJava: 接收到了事件2



    

  • 新的Observable发送error事件 = 原始Observable停止发送&不重新发送
    • 



06-27 18:06:37.814 23672-23672/com.gjj.frame D/RxJava: 开始采用subscribe连接
06-27 18:06:37.816 23672-23672/com.gjj.frame D/RxJava: 接收到了事件1
06-27 18:06:37.817 23672-23672/com.gjj.frame D/RxJava: 接收到了事件2
06-27 18:06:37.818 23672-23672/com.gjj.frame D/RxJava: 对Error事件作出响应：java.lang.Throwable: 不再重新订阅事件



    

  • 新的Observable发送其他事件= 原始Observable重新发送
    • 



06-27 18:08:13.130 23896-23896/com.gjj.frame D/RxJava: 开始采用subscribe连接
06-27 18:08:13.133 23896-23896/com.gjj.frame D/RxJava: 接收到了事件1
06-27 18:08:13.130 23896-23896/com.gjj.frame D/RxJava: 接收到了事件2
06-27 18:08:13.133 23896-23896/com.gjj.frame D/RxJava: 接收到了事件1
06-27 18:08:13.130 23896-23896/com.gjj.frame D/RxJava: 接收到了事件2
06-27 18:08:13.134 23896-23896/com.gjj.frame D/RxJava: 接收到了事件1
06-27 18:08:13.130 23896-23896/com.gjj.frame D/RxJava: 接收到了事件2



参考文章：
 Android RxJava：功能性操作符 全面讲解
























你可能感兴趣的:(RxJava操作符--->功能性操作符)






    

  • 【王道训练营】第二题 你的任务是计算a+b。
云梦之泽moon
c语言算法开发语言

    文章目录答案代码分析举例说明C语言基础知识：输入输出和算术操作符输入和输出示例1：使用`printf`和`scanf`函数示例2：使用`printf`函数打印多种类型的值示例3：使用算术操作符总结答案#includeintmain(){inta;intb;scanf("%d%d",&a,&b);printf("%d",a+b);return0;}代码分析这段代码是一个简单的C程序，它从用户输入两个
    

    • 

  • 合肥微信小程序开发一般需要多少钱
A挑战自我

    合肥做一个小程序价格是不等的，主要看客户需求和功能，一般普通的一个微信小程序，合肥小程序制作公司可能报价3~5k，功能性的5k以上。那么，小程序多少钱做一个？做一个微信小程序大概多少钱？下面跟随安徽云帮邦网络一起来看看吧！一个小程序的费用是根据你的需求而定的，因为影响到小程序价格的因素有很多，例如类型、功能、开发方式等等都会影响到最终的价格。所以，要想知道最终的价格，你需要告诉我，你想做一个什么类
    

    • 

  • Redis基础命令集详解——新手入门必备
Jz_Stu
Redisredis

    Redis基础命令集详解——新手入门必备文章目录Redis基础命令集详解——新手入门必备前言一、Redis安装与连接二、Redis数据类型及基本命令1、String（字符串）2、List（列表）可模拟双向列表（左进右出|右进左出）和栈（左进左出|右进右出）3、Set（集合）4、Hash（哈希）5、SortedSet（有序集合）6、其他功能性命令三、事务与批量操作总结前言Redis（RemoteDi
    

    • 

  • c++类型转换（持续更新）
gyqJulius_Caesar
C/C++程序设计c++java开发语言

    1.static_caststatic_cast是C++中的一个类型转换操作符（typecastoperator），用于执行静态类型转换。静态类型转换在编译时进行，用于将一种类型的值转换为另一种类型。static_cast操作符的语法为：static_cast(expression)//实例doubletest=5.5;intoutput=static_cast(test);//i=5其中new_
    

    • 

  • RxSwift如何选择操作符?
MMD_

    amb多个Observables中，取第一个发出元素的Observablebuffer缓存元素当元素达到某个数量，然后将元素集合发送出来catchError拦截一个error事件，将他替换成其他的元素或一组元素，使得正常结束catchErrorJustReturn将error事件替换成其他的一个元素，然后结束该序列combineLatest将多个Observables中最新的元素通过一个函数组合起
    

    • 

  • linux Shell 命令行-02-var 变量
老马啸西风
java

    拓展阅读linuxShell命令行-00-intro入门介绍linuxShell命令行-02-var变量linuxShell命令行-03-array数组linuxShell命令行-04-operator操作符linuxShell命令行-05-test验证是否符合条件linuxShell命令行-06-flowcontrol流程控制linuxShell命令行-07-func函数linuxShell命令
    

    • 

  • MongoDB聚合运算符：$dayOfMonth
原子星
杂谈mongodb数据库

    MongoDB聚合运算符：$dayOfMonth$dayOfMonth返回日期中“日”的部分，值的范围1~31。$dayOfMonth可以用于以下场景：提取日期字段的"日"部分：当需要从日期字段中提取出具体的天数时，可以使用$dayOfMonth。例如，有一个包含日期的集合，可以使用$dayOfMonth来获取每个日期的天数。按天进行分组和统计：当结合$group操作符使用时，$dayOfMont
    

    • 

  • equals与==的区别
多次拒绝offer
后端技术分享java

    一、对象类型不同1、equals()：是超类Object中的方法。2、==：是操作符。二、比较的对象不同1.equalsequals默认比较地址值如果类中重写了equals方法，比较内容是否相等。String、Date、File、包装类都重写了Object类的equals方法。如果类中没有重写equals方法，比较地址值是否相等（是否指向同一个地址值）。2.==比较运算符，返回的就是一个布尔值tr
    

    • 

  • 程序人生——Java开发中通用的方法和准则，Java进阶知识汇总
Perley620
#Java面试上岸专栏程序人生java职场和发展

    目录引出Java开发中通用的方法和准则建议1：不要在常量和变量中出现易混淆的字母建议2：莫让常量蜕变成变量建议3：三元操作符的类型务必一致建议4：避免带有变长参数的方法重载建议5：别让null值和空值威胁到变长方法建议6：覆写变长方法也循规蹈矩建议7：警惕自增的陷阱建议8：不要让旧语法困扰你建议9：少用静态导入建议10：不要在本类中覆盖静态导入的变量和方法建议11：养成良好的习惯，显式声明UID建
    

    • 

  • （day 4）JavaScript学习笔记（操作符）
m0_63165331
javascript运算符

    概述这是我的学习笔记，记录了JavaScript的学习过程，我是有一些Python基础的，因此在学习的过程中不自觉的把JavaScript的代码跟Python代码做对比，以便加深印象。我本人学习软件开发纯属个人兴趣，大学所学的专业也非软件工程相关专业，从事的工作也非编程领域，学习编程也只能在工作闲暇时间，因此难免有些专业术语不是那么专业，并且博客会不定时更新，还请多多包涵。如果你完全没接触过Jav
    

    • 

  • javascript:void(0);用法及常见问题解析
Java仗剑走天涯
JavaScriptjavascriptjavascriptvoid0voidjsvoid

    void操作符用法格式：javascript:void(expression)下面的代码创建了一个超级链接，当用户以后不会发生任何事。当用户链接时，void(0)计算为0，但Javascript上没有任何效果。单此处什么也不会发生下面的代码创建了一个超级链接，用户单时会提交表单。单此处提交表单下面代码则执行了subgo()函数，在这里，javascript:void(0),没启实质上的作用，它仅仅
    

    • 

  • 10X单细胞转录组个性化分析-拟时序分析
Seurat_Satija

    在发育过程中，细胞会对刺激做出反应，在整个生命过程中，从一种功能性“状态”转变为另一种功能性“状态”。处于不同状态的细胞表达的基因不同，产生蛋白质和代谢物的动态重复序列，从而完成它们的工作。当细胞在不同状态间转变时，会经历转录重组的过程，其中一些基因被沉默，而另一些基因被激活。这些瞬时状态通常难以表征，因为在更稳定状态之间纯化细胞是困难或不可能的。单细胞RNA-Seq可以使您在不需要纯化细胞的情况
    

    • 

  • 第五届核磁机器学习班（训练营：2023.6.5~6.17）
茗创科技

    茗创科技专注于脑科学数据处理，涵盖（EEG/ERP,fMRI,结构像,DTI,ASL,FNIRS）等，欢迎留言讨论及转发推荐，也欢迎了解茗创科技的脑电课程，数据处理服务及脑科学工作站销售业务，可添加我们的工程师（微信号MCKJ-zhouyi或17373158786）咨询。★课程简介★基于血氧水平依赖的功能磁共振成像(fMRI)技术,利用其数据构建的功能性脑网络后,发现脑并不是一个单纯对外界刺激进行
    

    • 

  • 对现有产品进行数据库版本的升级
草明
其他数据库安全

    何时升级数据库版本升级数据库版本是一个涉及到系统稳定性、性能、安全性和功能性的重要决策。以下是一些可能的情况和理由，可以考虑升级数据库版本：修复Bug和漏洞：新版本通常包含了对已知问题的修复和漏洞的修补程序，这些问题可能会影响到系统的稳定性和安全性。因此，当一个已知的严重漏洞被修复时，升级数据库版本是非常必要的。性能改进：新版本可能会带来性能方面的改进，例如优化查询执行计划、增加并发性能、减少资源
    

    • 

  • python比较大小
weixin_34326558
python数据结构与算法

    1、python的比较总是检查复合对象的所有部分，直到可以得出结果为止。2、会自动遍历嵌套的所有数据结构，有多深走多深，首次发现的差值将决定比较的结果3、==:操作符测试值的相等性4、is:表达式测试对象的一致性，表示同一个对象，在同一内存地址中python对象的大小比较规则：1、数字通过相对大小进行比较2、字符串按照字典顺序（编码顺序）,一个字符接一个字符进行比较3、列表和元组从左到右对每部分的
    

    • 

  • ?.和??
豆心
前端javascripthtml

    ?.可选链操作符用于访问可能为空或未定义的属性或方法，它允许我们安全地访问嵌套对象的属性，如果中间的属性为空或未定义，则不会抛出错误，而是返回undefined。constobj={foo:{bar:123}};//普通访问属性的方式constx=obj.foo.bar;//x=123//使用可选链操作符consty=obj?.foo?.bar;//y=123//如果对象未定义，则返回undefi
    

    • 

  • 软件安全测试报告模板_软件质量保证与测试（课后习题与答案）--仅供复习参考...
weixin_39687359
软件安全测试报告模板

    第1章软件测试基础一、填空题1.软件从“出生”到“消亡”的过程称为软件生命周期2.早期的线性开发模型称为瀑布开发模型。3.引入风险分析的开发模型为_螺旋开发模型。4.ISO/IEC9126:1991标准提出的质量模型包括.功能性、可靠性、可使用性、效率、可维护性、可移植性_6大特性。5.按照缺陷的严重程度可以将缺陷划分为_严重、一般、次要、建议6.验证软件单元是否符合软件需求与设计的测试称为_单元
    

    • 

  • 天德堂医话 015篇
本能学堂a昨年

    三看郭老方剂的经典性郭老对桂枝茯苓丸的运用桂枝茯苓丸，出自医圣张仲景的《金匮要略》，是治疗妇科疾病的一张名方。《金匱要略》妇人妊娠病脉证并治第二十：“……所以血不止者，其癓不去故也。当下其癥，桂枝茯苓丸主之。”经文中所说的“癥”，指腹腔内结块。结合“血不止者”，当属子宫内结块。这个结块则属于占位性病变，当包括囊肿，肌瘤，息肉，子宫内膜异位，功能性子宫出血等慢性妇科疾病。皆以桂枝茯苓丸主治。桂枝茯苓
    

    • 

  • vue3升级了什么
亮学长
vue.jsjavascriptecmascript

    Vue3在许多方面都进行了功能性升级和改进。以下是一些Vue3相对于Vue2的新功能和改进：CompositionAPI：引入了CompositionAPI，这是一个基于函数的API，使得组合逻辑更加灵活和可重用。CompositionAPI可以更好地帮助组织组件代码，尤其是对于大型复杂的组件。它提供了更好的代码组织和可维护性。性能优化：Vue3对虚拟DOM进行了改进，提高了反应性系统的性能。新的
    

    • 

  • 【转】MongoDB 中“$“操作符表达式汇总
是个小胖墩儿啊
MongoDBmongodb

    转自：https://www.cnblogs.com/fengting0913/p/14616629.html比较操作$eq释义:匹配等于指定值的文档示例:查询age=20的文档db.person.find({age:{$eq:20}})$gt释义:匹配大于指定值的文档示例:查询age>20的文档db.person.find({age:{$gt:20}})$gte释义:匹配大于等于指定值的文档示例
    

    • 

  • 系统设计的非功能需求
Real_man

    非功能性需求，是指软件产品为满足用户业务需求而必须具有且除功能需求以外的特性，包括安全性、可靠性、互操作性、健壮性为什么有非功能性需求？从决策角度来看，非功能性需求是对各种设计方案进行选择的标准非功能性需求也可称之为软件开发的“约束”，这主要是因为从最简单的到最复杂的软件系统，都有反映软件系统质量和特性的额外要求，它从各个角度对所考虑的可能采取的解决方案起约束和限制作用img非功能性需求主要有哪些
    

    • 

  • Swift Combine 使用 ObservableObject 与 SwiftUI 模型作为发布源 从入门到精通二十
AI架构师易筋
iOSswiftswiftui服务器

    Combine系列SwiftCombine从入门到精通一SwiftCombine发布者订阅者操作者从入门到精通二SwiftCombine管道从入门到精通三SwiftCombine发布者publisher的生命周期从入门到精通四SwiftCombine操作符operations和Subjects发布者的生命周期从入门到精通五SwiftCombine订阅者Subscriber的生命周期从入门到精通六S
    

    • 

  • SQL 子查询
山药鱼儿

    所谓SQL子查询就是嵌套在其他查询中的查询。子查询通常用于WHERE子句的IN操作符中进行过滤，以及用来填充计算列。下面我们从这两种使用场景展开学习。本节涉及到关系表如下：最上方的订单表Orders存储了订单ID、订单日期以及顾客ID；具体的订单信息存储在OrderItems表中，通过order_num进行关联；具体的顾客信息存储在顾客表Customers中，通过cust_id字段进行关联。使用子
    

    • 

  • c# 操作符原理及概念
李建军
C#

    1操作符概览2操作符的本质操作符的本质是函数（即算法）的简记法staticvoidMain(string[]args){Personpeople1=newPerson();Personpeople2=newPerson();people1.Name="王小丫";people2.Name="陈雪梅";Listnation=Person.GetMarry(people1,people2);foreac
    

    • 

  • 2018-05-30 变量 typeof() 和instanceof()
忙于未来的民工

    1:变量的类型变量分为基本类型和引用类型,5种基本数据类型和1种引用类型基本数据类型:StringBooleanNumberNullUndefined引用类型:Object正则类型的检测typeof()和instanceof()typeof()操作符在检测字符串布尔值数值undefined时没有问题,但在检测null类型时,会返回object类型instanceof这个函数是用来检测对象类型的,原
    

    • 

  • 【C++】---类和对象（中）默认成员函数 和 操作符重载
伤心男孩拯救世界（Code King）
C++c++开发语言

    前言：假如一个类中既没有成员变量也没有成员函数，那么这个类就是空类，空类并不是什么都没有，因为所有类都会生成如下6个默认成员函数：一、构造函数1、构造函数的定义及其特性对于日期类对象，我们可能会忘记调用Init函数进行初始化，C++为了解决这个问题，引入构造函数进行初始化。#includeusingnamespacestd;classDate{private:int_year;int_month;
    

    • 

  • 【C++】实现Date类的各种运算符重载
伤心男孩拯救世界（Code King）
C++c++开发语言

    上一篇文章只实现了operator==操作符重载，由于运算符较多，该篇文章单独实现剩余所有的运算符重载。继续以Date类为例，实现运算符重载：1.Date.h#pragmaonce#include#includeusingnamespacestd;classDate{private:int_year;int_month;int_day;public:voidPrint();Date(intyaer
    

    • 

  • 第三章 shell条件测试
[禾火]
shell脚本编程chrome前端运维

    目录1.1.用途1.2.基本语法1.2.1.格式：1.2.2.示例1.3.文件测试1.3.1.参数：1.3.2.示例1.4.整数测试1.4.1.作用1.4.2.操作符1.4.3.示例1.5.逻辑操作符1.5.1.符号1.5.2.例：1.6.命令分隔符1.7.案例分析1.1.用途为了能够正确处理Shell程序运行过程中遇到的各种情况，LinuxShell提供了一组测试运算符。通过这些运算符，Shel
    

    • 

  • 【C++航海王：追寻罗杰的编程之路】类与对象你学会了吗？(中)
枫叶丹4
C++c++开发语言visualstudio后端

    目录1->类的六个默认成员函数2->构造函数2.1->概念2.2->特性3->析构函数3.1->概念3.2->特性4->拷贝构造函数4.1->概念4.2->特征5->赋值运算符重载5.1->运算符重载5.2->赋值运算符重载5.3->前置++和后置++重载6->日期类的实现7->const成员8->取地址及const取地址操作符重载1->类的六个默认成员函数如果一个类中什么成员都没有，简称为空类。
    

    • 

  • MongoDB聚合操作符：$addToSet
原子星
mongodbmongodb数据库

    $addToSet返回一个无重复元素的数组，元素值是对每个分组文档执行表达式的结果。数组元素顺序未指定。$addToSet可以用于下列聚合阶段：$bucket$bucketAuto$group$setWindowFeilds语法{$addToSet:}用法如果表达式的值是个数组，$addToSet会把整个数组当成一个元素添加到返回的数组。如果表达式的值是一个文档，那么如果数组中的另一个文档与要添加
    

    • 

  • mondb入手
木zi_鸣
mongodb

    windows 启动mongodb  编写bat文件，
mongod --dbpath D:\software\MongoDBDATA
mongod --help  查询各种配置
配置在mongob
打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口
启动配置文件配置，
数据更灵活 
    

    • 

  • 大型高并发高负载网站的系统架构
bijian1013
高并发负载均衡

            扩展Web应用程序
一.概念
        简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种：
        1.
    

    • 

  • DISPLAY变量和xhost(原创)
czmmiao
display

    DISPLAY
在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0
    

    • 

  • 获取B/S客户端IP
周凡杨
java编程jspWeb浏览器

       最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为：
   String ip = InetAddress.getLocalHost().getHostAddress();
然而对于WEB
    

    • 

  • 浅谈类和对象
朱辉辉33
编程

        类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的，
占用存储空间。
    类是由属性和方法构成的，基本格式是public  class 类名{
//定义属性
private/public 数据类型 属性名；
//定义方法
publ
    

    • 

  • android activity与viewpager+fragment的生命周期问题
肆无忌惮_
viewpager

    有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。
第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。
super.onResume();
bindService(intent, conn, BIND_AUTO_CREATE);

    

    • 

  • base64Encode对图片进行编码
843977358
base64图片encoder

    /**
* 对图片进行base64encoder编码
*
* @author mrZhang
* @param path
* @return
*/
public static String encodeImage(String path) {
BASE64Encoder encoder = null;
byte[] b = null;
I
    

    • 

  • Request Header简介
aigo
servlet

    当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    
    

    • 

  • HttpClient4.3 创建SSL协议的HttpClient对象
alleni123
httpclient爬虫ssl

    public class HttpClientUtils
{
public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){
SSLContext sslContext=null;
try
{
sslContext=new SSLContextBuilder().l
    

    • 

  • java取反 -右移-左移-无符号右移的探讨
百合不是茶
位运算符 位移

    取反：
在二进制中第一位，1表示符数，0表示正数
byte a = -1;
原码：10000001
反码：11111110
补码：11111111
//异或: 00000000
byte b = -2;
原码：10000010
反码：11111101
补码：11111110
//异或: 00000001

    

    • 

  • java多线程join的作用与用法
bijian1013
java多线程

            对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t
    

    • 

  • Java发送http请求(get 与post方法请求)
bijian1013
javaspring

    PostRequest.java
package com.bijian.study;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURL
    

    • 

  • 【Struts2二】struts.xml中package下的action配置项默认值
bit1129
struts.xml

    在第一部份，定义了struts.xml文件，如下所示：
 
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts
    

    • 

  • 【Kafka十三】Kafka Simple Consumer
bit1129
simple

    代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。
实际情况是需要将host和port绑定到一起，
 
package kafka.examples.lowlevel;
import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
impo
    

    • 

  • nodejs学习api
ronin47
nodejs api

    NodeJS基础 什么是NodeJS
JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。
每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum
    

    • 

  • java-64.寻找第N个丑数
bylijinnan
java

    
public class UglyNumber {
/**
* 64.查找第N个丑数
具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url]
*
题目：我们把只包含因子
2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14
    

    • 

  • 二维数组（矩阵）对角线输出
bylijinnan
二维数组

    
/**
二维数组 对角线输出 两个方向
例如对于数组：
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 },
{ 13, 14, 15, 16 },
slash方向输出：
1
5 2
9 6 3
13 10 7 4
14 11 8
15 12
16
backslash输出：
4
3
    

    • 

  • [JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新)
comsci
工作流

       既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理
   大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把
    

    • 

  • redis常见使用
cuityang
redis常见使用

    redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets
引入jar包 jedis-2.1.0.jar  (本文下方提供下载)
package redistest;
import redis.clients.jedis.Jedis;
public class Listtest
    

    • 

  • 配置多个redis
dalan_123
redis

    配置多个redis客户端
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo
    

    • 

  • attrib命令
dcj3sjt126com
attr

     
attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统. 
  只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护. 
  存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件. 

    

    • 

  • Yii使用公共函数
dcj3sjt126com
yii

    在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。 在入口文件index.php里添加 require_once('protected/function.php'); 即可对其引用，成为公用的函数集合。 function.php如下：
  <?php /**   * This is the shortcut to D
    

    • 

  • linux 系统资源的查看（free、uname、uptime、netstat）
eksliang
netstatlinux unamelinux uptimelinux free

    linux 系统资源的查看
转载请出自出处：http://eksliang.iteye.com/blog/2167081
 
http://eksliang.iteye.com 一、free查看内存的使用情况
语法如下：
 
free [-b][-k][-m][-g] [-t]
参数含义
-b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m
    

    • 

  • JAVA的位操作符
greemranqq
位运算JAVA位移<<>>>

    最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。
 
1.按位操作符 ：
   按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。
   与（&）运算：
   1&1 = 1, 1&0 = 0, 0&0 &
    

    • 

  • Web前段学习网站
ihuning
Web

     
Web前段学习网站
菜鸟学习：http://www.w3cschool.cc/
 
JQuery中文网：http://www.jquerycn.cn/
 
内存溢出：http://outofmemory.cn/#csdn.blog
 
http://www.icoolxue.com/
 
http://www.jikexue
    

    • 

  • 强强联合：FluxBB 作者加盟 Flarum
justjavac
r

    原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac
FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，
    

    • 

  • java统计在线人数（session存储信息的）
macroli
javaWeb

    这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！
 
由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！
我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。
1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。
public class Ses
    

    • 

  • bootstrp carousel初体验 快速构建图片播放
qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象

    img{
border: 1px solid white;
box-shadow: 2px 2px 12px #333;
_width: expression(this.width > 600 ? "600px" : this.width + "px");
_height: expression(this.width &
    

    • 

  • SparkSQL读取HBase数据，通过自定义外部数据源
superlxw1234
sparksparksqlsparksql读取hbasesparksql外部数据源

    关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源
 
 
前面文章介绍了SparSQL通过Hive操作HBase表。
 
SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访
    

    • 

  • Spring Boot 1.3.0.M1发布
wiselyman
spring boot

        Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下：
 
1.提供一个新的sprin
    

    •