谢尔顿
谢尔顿

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操作符--->功能性操作符)

        

            

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

                        
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
    
                    
    • 
                    
  • 【C语言】- 自定义类型：结构体、枚举、联合
                        Cavalier_01
C语言
                        
    【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
    
                    
    • 
                    
  • 电子技术引领汽车智能新浪潮，尽在AUTO TECH 2025广州国际汽车电子技术盛会
                        JSZNZZ
汽车
                        
    随着科技的持续进步，汽车电子行业正迎来深刻的转型。这一变革的显著特征是从传统的机械控制方式逐渐过渡到智能化和网联化的管理系统。这种转变不仅提升了汽车电子产品的技术复杂性，还极大地丰富了其创新性和功能性。在这个过程中，产品开发的质量和效率变得尤为关键，它们直接决定了企业在激烈竞争环境中的市场地位和商业成功。面对快速变化的市场需求，汽车电子行业在产品开发过程中遇到了多方面的挑战。其中，信息孤岛是一个显
    
                    
    • 
                    
  • malloc和new的区别及联系
                        月夜星辉雪
数据结构
                        
    一.区别1.用法上malloc是一个函数，而new是C++一个操作符malloc需要手动计算开辟的空间大小，new后面只需跟上空间的类型，如果有多个对象，加上[]给个数即可malloc申请的空间不能初始化，而new可以malloc返回void*，需要强制类型转换，而new返回对应类型的指针malloc失败会返回空指针，需要手动检查；new失败抛出异常，要用catch捕获2.底层原理上申请自定义类型
    
                    
    • 
                    
  • 一文搞懂应用架构的3个核心概念
                        公众号-架构师汤师爷
后端架构设计JavaSaaS
                        
    如果你是一名业务开发，你可能要说，我整天就是做CRUD（增删改查），哪里需要了解什么应用架构设计？经常有人说，程序员35岁之后很容易陷入瓶颈，被行业淘汰，我觉得原因其实就在此。有些朋友在写代码的时候，可能没有太多考虑非功能性的需求、扩展性，只是完成功能，觉得能用就好。做事情的时候，也没有长远的规划，只是把眼前的事情做好就满足了。我面试过很多大龄候选人，他们的简历长达十几页，项目经历有几十个。然而，
    
                    
    • 
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • 运算符、一元运算符、自增、自减
                        玖岁灬

                        
    运算符运算符也叫操作符通过运算符可以对一个或多个值进行运算,并获取运算结果比如：typeof就是运算符，可以来获得一个值的类型，它会将该值的类型以字符串的形式返回"number""string""boolean""undefined""object"算数运算符当对非Number类型的值进行运算时，会将这些值转换为Number然后在运算任何值和NaN做运算都得NaN++可以对两个值进行加法运算，并将
    
                    
    • 
                    
  • Prometheus运维六 PromQL查询语言详解及操作
                        安顾里
Prometheus监控类大数据kubernetes运维linux
                        
    海阔凭鱼跃，天高任鸟飞Prometheus官网：https://prometheus.io/文章目录1.什么是PromQL?2.PromQL的基本使用2.1时间序列选择器2.1.1瞬时向量选择器2.2区间向量选择器2.2.1范围向量选择器2.2.2时间位移操作2.2.3使用聚合操作2.3标量和字符串3.PromQL操作符4.内置常用函数5.HTTPAPI操作PromQL6.使用建议1.什么是Pro
    
                    
    • 
                    
  • JavaScript创建Object对象的方法
                        流落的小鬼
javascript前端
                        
    JavaScript创建Object对象的方法1、使用new操作符后跟Object构造函数varobj=newObject()person.name='AAA'person.age=192、对象字面量varobj={name:'BBB',age:20}3、与newObject相同varobj={}person.name="CCC"person.age=21
    
                    
    • 
                    
  • 参松养心胶囊(转)
                        三闲居士a

                        
    参松养心胶囊胡洋上海三甲医院呼吸内科副主任医师参松养心胶囊是一种中成药，其主要成分为桑寄生、山茱萸、酸枣仁、龙骨、人参、土鳌虫、甘松、黄连、独活、丹参、赤芍。其临床上主要作用为治疗心律失常。参松养心胶囊治疗由于冠心病、心肌炎、风心病、高心病等心脏病引起的室性早搏显著优于慢心律，治疗由于劳累过度、酗酒、情绪激动等引起的功能性早搏效果显著，治疗阵发性房颤效果与心律平相当。目前公认的心律失常治疗药物，仍
    
                    
    • 
                    
  • 第五届核磁机器学习班（训练营：2023.6.5~6.17）
                        茗创科技

                        
    茗创科技专注于脑科学数据处理，涵盖（EEG/ERP,fMRI,结构像,DTI,ASL,FNIRS）等，欢迎留言讨论及转发推荐，也欢迎了解茗创科技的脑电课程，数据处理服务及脑科学工作站销售业务，可添加我们的工程师（微信号MCKJ-zhouyi或17373158786）咨询。★课程简介★基于血氧水平依赖的功能磁共振成像(fMRI)技术,利用其数据构建的功能性脑网络后,发现脑并不是一个单纯对外界刺激进行
    
                    
    • 
                    
  • C#的linq语句
                        木生火18624
C#开发
                        
    /查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
    
                    
    • 
                    
  • [C++11] 移动语意和移动构造函数
                        图王大胜
计算机学科基础开发语言c++移动语意移动构造函数
                        
    说明：移动语义（MoveSemantics）是C++11引入的一个重要概念，旨在提高大型对象（特别是那些涉及资源管理的对象）的复制效率。移动语义允许资源从一个对象“移动”到另一个对象，而不是进行昂贵的复制操作。这种机制通过右值引用（right-valuereference）和移动构造函数（moveconstructor）以及移动赋值操作符（moveassignmentoperator）来实现。而移
    
                    
    • 
                    
  • el-table:根据 scope.row.type 的值来显示不同的类型
                        J不A秃V头A
前端vue.jselementuijavascript
                        
    想要根据scope.row.type的值来显示不同的房源类型（转租、短租、长租、招租）转租短租长租招租未知类型这里，我们使用了v-if和v-else-if指令来检查scope.row.type的值，并根据该值显示相应的文本。如果scope.row.type的值不是0、1、2或3，则通过v-else显示“未知类型”。注意，这里的===是严格等于操作符，它会检查两边的值和类型是否都相等。这是推荐的做法
    
                    
    • 
                    
  • Elasticsearch之bool查询
                        cyt涛
javaelasticsearch大数据搜索引擎bool布尔查询全文检索
                        
    bool查询是Elasticsearch中最常用的复合查询类型，允许将多个查询组合在一起。它通过逻辑操作符（如must、should、must_not和filter）来构建复杂的查询条件，从而满足多条件匹配、逻辑与（AND）、或（OR）、非（NOT）的查询需求。bool查询主要由四个部分组成：must：必须满足的条件（类似于SQL中的AND）。should：应该匹配的条件（类似于SQL中的OR）。
    
                    
    • 
                    
  • 性价比莆田鞋价格一览表，你买的价格再低也低不过这家
                        优鞋之家

                        
    性价比莆田鞋价格一览表，你买的价格再低也低不过这家当太阳的光辉铺洒大地，每个人都在匆忙地寻找自己的舞台，而在这个时代的潮流中，"莆田鞋价格一览表"正如一颗跃动的新星，照亮了追求时尚而经济的消费者们的道路。伟大的设计师乔布斯曾经说过：“设计不仅仅是外观和感觉，设计是功能。”这句话也同样适用于莆田鞋，它们以合理的价格和优秀的功能性，赢得了市场的一席之地。作为知识的传播者，我们将通过这篇科普文章为您展开
    
                    
    • 
                    
  • SQL日期函数
                        dlwlrma ⥳
兴趣类sql数据库
                        
    目录引言：一：获取日期时间函数1.1获取当前时间1.2获取当前日期二：日期格式化2.1日期转指定格式字符串2.2字符串转日期三：日期间隔3.1增加日期间隔3.2减去一个时间间隔3.3日期相差天数3.4相差时间（小时）四：星期操作五：其他操作六：总结引言：在SQL中，日期函数具有多种重要作用：1.数据筛选和查询：可以根据特定的日期范围来获取所需的数据。例如，通过BETWEEN操作符和日期函数，筛选出
    
                    
    • 
                    
  • 【Python】02.Python 的基础概念
                        卡戎-caryon
Pythonpython开发语言笔记
                        
    一、常量和表达式形如1+2-3这样的算式，在编程语言中称为表达式,算式的运算结果,称为表达式的返回值其中1,2,3这种称为字面值常量,+-*/这种称为运算符或者操作符二、变量与类型2.1变量的定义有的时候,我们需要进行的计算可能更复杂一些,需要把一些计算的中间结果保存起来.这个时候就需要用到变量变量可以视为是一块能够容纳数据的空间.这个空间往往对应到“内存”这样的硬件设备上2.2变量的语法2.2.
    
                    
    • 
                    
  • python的高级特性
                        咸鱼有梦想呀

                        
    在python中，代码是越少越好，越简单越好。因此就有了python常用的高级特性。切片（Slice）切片操作符，用于经常取指定索引范围的操作。好处就是减少使用循环eg：list切片L[0:3]表示从索引0开始取，直到索引3为止，但不包括索引3。如果第一个索引是0还可以省略。list切片倒数切片。-1是倒数第一个元素的索引。切片不但可以取相邻的，还可以每两个取一次，或者每5个取一次。list切片t
    
                    
    • 
                    
  • FPGA 编程基础, 赋值操作符, 运算符使用, 条件表达式, 信号操作方法
                        行者..................
fpga开发
                        
    1.**赋值符号**：-**"="**：阻塞赋值，即在`always`模块中该语句会被立即执行。-**""**：大于，如果A>B则结果为TRUE，否则为FALSE。-**">="**：大于等于，如果A>=B则结果为TRUE，否则为FALSE。-**"=="**：等于，如果A==B则结果为TRUE，否则为FALSE。-**"!="**：不等于，如果A!=B则结果为TRUE，否则为FALSE。4.**
    
                    
    • 
                    
  • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
    
                    
    • 
                    
  • Rxjava2你应该懂的源码，其实并不难（二）
                        kwbsky

                        
    接上篇继续。一、线程切换observeOnObservable.just("1").subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer)我们知道，当调用observeOn之后，后面执行的代码都将切换到他指定的线程，除非再次调用observeOn切换其他线程。上源码：@Ch
    
                    
    • 
                    
  • C++ primer笔记---指针
                        六灬道
C++笔记C++
                        
    1、指针存放某个对象的地址，要想获取该地址，需要使用取地址符（操作符&）；定义指针类型的方法将声明符写成*d的形式，其中d是变量名。引用不是对象，没有实际地址，不能定义指向引用的指针；2、指针的值（即地址）应属下列4种状态之一：1、指向一个对象；2、指向紧邻对象所占空间的下一个位置；3、空指针，意味着指针没有指向任何对象。4、无效指针，也就是上述情况之外的其他值。3、如果指针指向了一个对象，则允许
    
                    
    • 
                    
  • TC、IXIA、C50等测试仪器
                        weixin_45544617
网络服务器运维
                        
    TC、IXIA、C50等测试仪器在各自的领域内都具有较高的专业性和广泛的应用。以下是对这些测试仪器的一般性描述：TC测定仪TC测定仪（通常也涉及TIC和TOC的测定）主要用于分析样品中的总碳（TC）、总有机碳（TOC）和总无机碳（TIC）含量。这类仪器广泛应用于制药、海水、食品、地质样品、污泥、饮用水和废水等多个领域。TC测定仪通常具备以下特点：多功能性：可同时测定TC、TOC和TIC含量，通过自
    
                    
    • 
                    
  • Android视频开发进阶-关于视频的那些术语，android软件开发计算器
                        wa32saa
程序员架构移动开发android
                        
    原文出处：jianshu正文说到安卓的视频开发，大多数朋友们都是用着开源的播放器，或者安卓自带的nativemediaplayer，拿来主义居多，我曾经也是。。。最近这半年因为开始着手重构公司的播放器,也开始学习了很多视频音频开发的相关知识，抱着独乐乐不如众乐乐的想法，开始写一些值得分享的东西。这次的连载和之前的RxJava分享一样，会分开不容的章节。第一次我打算分享一下视频开发中常见的一些知识点
    
                    
    • 
                    
  • 2024最新Android大厂面试真题大全（附答案）
                        imtokenmax合约众筹
2024年程序员面试android面试职场和发展
                        
    五、架构设计和设计模式1.谈谈你对Android设计模式的理解2.MVCMVPMVVM原理和区别3.你所知道的设计模式有哪些？4.项目中常用的设计模式5.手写生产者/消费者模式6.写出观察者模式的代码7.适配器模式，装饰者模式，外观模式的异同？8.用到的一些开源框架，介绍一个看过源码的，内部实现过程。9.谈谈对RxJava的理解10.Rxjava发送事件步骤11.RxJava的作用，与平时使用的异
    
                    
    • 
                    
  • 软考笔记--软件系统质量属性
                        赤露水
软考笔记
                        
    一.软件系统质量属性的概念软件系统的质量就是“软件系统与明确地和隐含的定义的需求相一致的程度”。更具体地说，软件系统质量就是软件与明确地叙述的功能和性能需求文档中明确描述的开发标准以及任何专业开发的软件产品都应该具有的隐含特征相一致的程度。从管理的角度对软件系统质量数据进行度量，可以将影响软件质量的主要因素划分为6种纬度特性：功能性。可靠性，易用性，效率，维护性与可移植性。其中，功能包括适合性，准
    
                    
    • 
                    
  • C语言深入了解指针一(14)
                        tan180°
Cc语言
                        
    文章目录前言一、内存和地址内存究竟该如何理解编址二、指针变量和地址取地址操作符&解引用操作符*指针变量的大小总结前言  终于来到指针啦！如前篇末尾总结所说，这是你们马上要下大功夫的地方  但是，就像我们上初中的时候，有人说函数难；我们上高中的时候，有人说导数、圆锥难；上大学的时候，有人说微积分难，事实上，别被吓到了，先勇敢尝试，迈过去了也就那么回事~一、内存和地址脱离内存和地址讲指针就是耍流氓！内
    
                    
    • 
                    
  • Python魔法之旅-魔法方法(01)
                        神奇夜光杯
python开发语言魔法方法学习和成长基础知识
                        
    目录一、概述1、定义2、作用二、主要应用场景1、构造和析构2、操作符重载3、字符串和表示4、容器管理5、可调用对象6、上下文管理7、属性访问和描述符8、迭代器和生成器9、数值类型10、复制和序列化11、自定义元类行为12、自定义类行为13、类型检查和转换14、自定义异常三、学习方法1、理解基础2、查阅文档3、编写示例4、实践应用5、阅读他人代码6、参加社区讨论7、持续学习8、练习与总结9、注意兼容
    
                    
    • 
                                
  • 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
    
                                
    •