花熊
花熊

Android-0.RxJava2简介

文章目录

    • RxJava2 依赖
      • 作用 - 异步
      • 模式 - 观察者模式
      • 结构 - 响应式编程
      • 优势 - 逻辑简洁
    • RxJava2 入门
      • 事件产生
      • 事件消费
      • 事件订阅
      • 区分回调动作
      • 入门示例
    • RxJava 进阶
      • Scheduler线程控制
      • 变换
        • map操作符
        • flatMap操作符
    • RxJava 其他常用操作符
      • 1.from系列
      • 2.just
      • 3.filter
      • 4.take
      • 5.doOnNext
      • 6.debounce
      • 7.merge
      • 8.concat
      • 9.compose
      • 10.first
      • 11.timer
      • 12.interval
      • 13.throttleFirst
      • 14.Single
      • 15.Subject
    • RxJava取消订阅
    • 总结

RxJava2 依赖

RxJava 在Github Repo上给的解释是：

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.

一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。

在gradle中做以下依赖以使用RxJava2：

implementation "io.reactivex.rxjava2:rxjava:2.2.5"
implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'

 

作用 - 异步

上面 这段解释，重点就在于异步！RxJava精华可以浓缩为异步两个字，其核心的东西不外乎两个：

1.  Observable（被观察者） 
2.  Observer/Subscriber（观察者）

Observables可以发出一系列的 事件，这里的事件可以是任何东西，例如网络请求、复杂计算处理、数据库操作、文件操作等等，事件执行结束后交给 Observer/Subscriber 的回调处理。

 

模式 - 观察者模式

观察者模式是一种对象的行为模式，是 Java 设计模式中很常用的一个模式。

RxJava 是一种扩展的观察者模式！从windows的理解角度来说说，它非常类似于REDM中的Event绑定事件，只是通过模板化加了更多的控制。

 

结构 - 响应式编程

响应式？顾名思义，就是“你变化，我响应”。举个栗子，a = b + c; 这句代码将b+c的值赋给a，而之后如果b和c的值改变了不会影响到a，然而，对于响应式编程，之后b和c的值的改变也动态影响着a，意味着a会随着b和c的变化而变化。

响应式编程的组成为Observable/Operator/Subscriber，RxJava在响应式编程中的基本流程如下：

Observable -> Operator 1 -> Operator 2 -> Operator 3 -> Subscriber

这个流程，可以简单的理解为：

  1. Observable 广播一系列事件，他是事件的产生(发送)者。
  2. Subscriber 负责监听处理事件，他是事件的消费(监听)者。
  3. Operator 是对 Observable 发出的事件在接收前进行修改和变换。
  4. 若事件从产生(发送)到消费(监听)不需要其他处理，则可以省略掉中间的 Operator，从而流程变为 Obsevable -> Subscriber。
  5. Subscriber 通常在主线程执行，所以原则上不要去处理太多的事务，而这些复杂的事务处理则交给 Operator。

优势 - 逻辑简洁

Rx 优势可以概括为四个字，那就是 逻辑简洁。然而，逻辑简洁并不意味着代码简洁，但是，由于链式结构，一条龙，你可以从头到尾，从上到下，很清楚的看到这个链式结构的执行顺序。对于开发人员来说，代码质量并不在于代码量，而在于逻辑是否清晰简洁，可维护性如何，代码是否健壮！
举个简单栗子,暂时不需要过多理解，后面会一一道来：

        Observable.just("Hello World!")
                .map(new Function() {
                    @Override
                    public String apply(String s) throws Exception {
                        return s + "I am hgy413!";
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        Toast.makeText(Main2Activity.this, s, Toast.LENGTH_SHORT).show();
                    }
                });

效果图:

Android-0.RxJava2简介_第1张图片

RxJava2 入门

前面讲了那么多，大家在概念上对RxJava有一个初步的认识就好，接下来，将为您解开RxJava神秘的面纱~~

无需过分纠结于“事件”这个词，暂时可以简单的把“事件”看成是一个值，或者一个对象。

  1. 事件产生，就是构造要传递的对象。
    2.事件处理变换，就是改变传递的对象，可以改变对象的值，或是干脆创建个新对象，新对象类型也可以与源对象不一样。
    3.事件处理，就是接收到对象后要做的事。

 

事件产生

RxJava创建一个事件比较简单，由 Observable 通过 create 操作符来创建。举个栗子，还是经典的 HelloWorld：

        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                // 发送一个 Hello World 事件
                emitter.onNext("Hello World!");

                // 事件发送完成
                emitter.onComplete();
            }
        });

这段代码可以理解为， Observable 发出了一个类型为 String ，值为 “Hello World!” 的事件，仅此而已。

ObservableEmitter 可以理解为发射器，是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value) 、onComplete()和onError(Throwable error)可以分别发出next事件、complete事件和error事件。 如果只关心next事件的话，只需单独使用onNext()即可。

需要特别注意，emitter的onComplete()调用后，Consumer不再接收任何onNext(T value) 事件，在onComplete()调用前，onNext(T value)可多次调用。

上面这段代码，也可以通过just操作符进行简化。RxJava常用操作符后面会详细介绍，这里先有个了解。

 Observable observable = Observable.just("Hello World!");

这样，是不是简单了许多？

 

事件消费

有事件产生，自然也要有事件消费。RxJava 可以通过 subscribe 操作符，对上述事件进行消费。首先，先创建一个观察者。

Observer observer = new Observer() {
	       private Disposable disposable;
            @Override
            public void onSubscribe(Disposable d) {
           		 disposable = d;
            }

            @Override
            public void onNext(String s) {
           		 if (.....）// 为异常数据时，解除订阅
                    disposable.dispose();
                }
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {
            }
        };

第一个回调方法onSubscribe, 传递参数为Disposable ,用于解除订阅,如上代码所示：disposable.dispose()。

 

事件订阅

最后，我们可以调用 subscribe 操作符， 进行事件订阅。

 observable.subscribe(observer);

在 Observer实现的另三个方法中，顾名思义，对应三种不同状态：

  1. onComplete(): 事件全部处理完成后回调。
  2. onError(Throwable t): 事件处理异常回调。
  3. onNext(T t): 每接收到一个事件，回调一次。

 

区分回调动作

对于事件消费与事件订阅来说，好像为了打印一个 “Hello World！” 要费好大的劲… 其实，RxJava 自身提供了精简回调方式，我们可以为 Observer 中的三种状态根据自身需要分别创建一个回调动作 Action：

        Action onCompleteAction = new Action() {
            @Override
            public void run() throws Exception {
                Log.i(TAG, "complete");
            }
        };

        Consumer onNextAction = new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, s);
            }
        };

        Consumer onErrorAction = new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
            }
        };

那么，RxJava 的事件订阅支持以下三种不完整定义的回调。

observable.subscribe(onNextAction);
observable.subscribe(onNextAction,onErrorAction);
observable.subscribe(onNextAction,onErrorAction,onCompleteAction);

我们可以根据当前需要，传入对应的 Action， RxJava 会相应的自动创建 Observer。

1.Action 表示一个无回调参数的Action。
2.Consumer表示一个含有一个回调参数的Action。
3.BiConsumer表示一个含有二个回调参数的Action。
4.Consumer表示一个含有N个回调参数的Action。

 

入门示例

前面讲解了事件的产生到消费、订阅的过程，下面就举个完整的例子。从res/mipmap中取出一张图片，显示在ImageView上。

        final ImageView ivLogo = (ImageView) findViewById(R.id.ivLogo);
        Observable.create(new ObservableOnSubscribe(){

            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                // 从mipmap取出一张图片作为Drawable对象
                Drawable drawable = getResources().getDrawable(R.mipmap.ic_launcher);

                // 把Drawable对象发送出去
                emitter.onNext(drawable);
                emitter.onComplete();
            }
        })
        .subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(Drawable drawable) {
                // 接收到Drawable对象，显示在ImageView上
                ivLogo.setImageDrawable(drawable);
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.toString());
            }

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

效果图:

Android-0.RxJava2简介_第2张图片

上面示例是 RxJava 最基本的一个用法。稍微消化一下，继续~~

 

RxJava 进阶

 

Scheduler线程控制

默认情况下，RxJava事件产生和消费均在同一个线程中，例如在主线程中调用，那么事件的产生和消费都在主线程。

那么问题来了，假如事件产生的过程是耗时操作，比如网络请求，结果显示在UI中，这个时候在主线程执行对于网络请求就不合适了，而在子线程执行，显示结果需要进行UI操作，同样不合适~~

所以，RxJava 的第一个牛逼之处在于可以自由切换线程！那么，如何做？

在 RxJava 中，提供了一个名为 Scheduler 的线程调度器，RxJava 内部提供了调度器，分别是：

  1. Schedulers.io(): 用于IO密集型的操作，例如读写SD卡文件，读写文件，查询数据库，访问网络等 ，具有线程缓存机制，在此调度器接收到任务后，先检查线程缓存池中，是否有空闲的线程，如果有，则复用，如果没有则创建新的线程，并加入到线程池中，如果每次都没有空闲线程使用，可以无上限的创建新线程。 不要在此调度程序上执行计算工作，以免产生不必要的线程。
  2. Schedulers.newThread(): 在每执行一个任务时创建一个新的线程，不具有线程缓存机制，因为创建一个新的线程比复用一个线程更耗时耗力，虽然使用Schedulers.io( )的地方，都可以使用Schedulers.newThread( )，但是，Schedulers.newThread( )的效率没有Schedulers.io( )高。
  3. Schedulers.computation()：用于CPU 密集型计算任务，即不会被 I/O 等操作限制性能的耗时操作，例如xml,json文件的解析，Bitmap图片的压缩取样等，具有固定的线程池，大小为CPU的核数。不可以用于I/O操作，因为I/O操作的等待时间会浪费CPU。
  4. Schedulers.trampoline():在当前线程立即执行任务，如果当前线程有任务在执行，则会将其暂停，等插入进来的任务执行完之后，再将未完成的任务接着执行。
  5. Schedulers.single():拥有一个线程单例，所有的任务都在这一个线程中执行，当此线程中有任务执行时，其他任务将会按照先进先出的顺序依次执行。
  6. AndroidSchedulers.mainThread():在Android UI线程中执行任务，为Android开发定制。

我们可以通过 subscribeOn() 和 observeOn() 这两个方法来进行线程调度。举个栗子：

依然还是显示一张图片，不同的是，这次是从网络上加载图片

        final ImageView ivLogo = (ImageView) findViewById(R.id.ivLogo);

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                try {
                    Drawable drawable = Drawable.createFromStream(new URL("https://ss2.baidu.com/6ONYsjip0QIZ8tyhnq/it/u=2502144641,437990411&fm=80&w=179&h=119&img.JPEG").openStream(), "src");
                    emitter.onNext(drawable);
                } catch (IOException e) {
                    emitter.onError(e);
                }
            }
        })
        // 指定 subscribe(ObservableEmitter emitter)调用的线程
        .subscribeOn(Schedulers.io())
        // 指定 onCompleted, onError, onNext回调的线程
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer(){
            private Disposable disposable;
            @Override
            public void onSubscribe(Disposable d) {
                disposable = d;
            }

            @Override
            public void onNext(Drawable drawable) {
                // 接收到Drawable对象，显示在ImageView上
                ivLogo.setImageDrawable(drawable);
            }

            @Override
            public void onError(Throwable e) {
                disposable.dispose();
            }

            @Override
            public void onComplete() {

            }
        });

效果图:

Android-0.RxJava2简介_第3张图片

所以，这段代码就做一件事，在 io 线程加载一张网络图片，加载完毕之后在主线程中显示到ImageView上。

 

变换

变换的概念不好理解吧？举个简单的栗子，我们对上述示例进行改写。

 

map操作符

 final ImageView ivLogo = (ImageView) findViewById(R.id.ivLogo);

        Observable.create(new ObservableOnSubscribe() {

            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("https://ss2.baidu.com/6ONYsjip0QIZ8tyhnq/it/u=2502144641,437990411&fm=80&w=179&h=119&img.JPEG");
            }
        }).map(new Function() {
            @Override
            public Drawable apply(String s) throws Exception {
                try {
                    Drawable drawable = Drawable.createFromStream(new URL(s).openStream(), "src");
                    return drawable;
                } catch (IOException e) {

                }
                return null;
            }
        })
                // 指定 subscribe(ObservableEmitter emitter)调用的线程
                .subscribeOn(Schedulers.io())
                // 指定 onCompleted, onError, onNext回调的线程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer() {
                    private Disposable disposable;

                    @Override
                    public void onSubscribe(Disposable d) {
                        disposable = d;
                    }

                    @Override
                    public void onNext(Drawable drawable) {
                        // 接收到Drawable对象，显示在ImageView上
                        ivLogo.setImageDrawable(drawable);
                    }

                    @Override
                    public void onError(Throwable e) {
                        disposable.dispose();
                    }

                    @Override
                    public void onComplete() {

                    }
                });

经过改写代码后，有什么变化呢？ Observable 创建了一个 String 事件，也就是产生一个url，通过 map 操作符进行变换，返回Drawable对象，这个变换指的就是通过url进行网络图片请求，返回一个Drawable。所以简单的来说就是把String事件，转换为Drawable事件。逻辑表示就是：

Observable --> map变换 --> Observable

那么，Function是什么呢？与 前面的ActionX 类似,不同的是 Function有返回值，而 ActionX没有。为什么需要返回值呢？目的就在于对象的变换，由String对象转换为Drawable对象。

1.Function 表示一个无参数的Function。
2.BiFunction表示一个含有1个参数的Function。
3.Function3-Function9表示一个含有2-8参数的Function。

 

flatMap操作符

不难发现，上述的 map 操作符，是一对一的变换，并且返回的是变换后的对象。而 flatMap 操作符可以适应一对多，并且返回的是一个 Observable 。

    public void onTest5(View view) {

        List list = Arrays.asList(1, 2, 3);

        Observable.fromIterable(list)
                .flatMap(new Function>() {
                    @Override
                    public ObservableSource apply(Integer integer) throws Exception {
                        Log.i(TAG, "开始执行，第" + integer + "圆球的任务 |  ThreadName=" + Thread.currentThread().getName());
                        return getObservable(integer);
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.i(TAG, "已完成" + s + " |  ThreadName=" +Thread.currentThread().getName());
                    }
                });
    }

    public static Observable getObservable(final int integer) {
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("第" + integer + "圆球的第1个棱形任务");
                if(integer != 1) {
                    // 第2和第3个圆球的第二个任务延时。
                    Thread.sleep(5 * 1000);
                }
                emitter.onNext("第" + integer + "圆球的第2个棱形任务");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread());
    }

运行结果：

Main2Activity: 开始执行，第1圆球的任务 |  ThreadName=main
Main2Activity: 开始执行，第2圆球的任务 |  ThreadName=main
Main2Activity: 开始执行，第3圆球的任务 |  ThreadName=main
Main2Activity: 已完成第1圆球的第1个棱形任务 |  ThreadName=RxNewThreadScheduler-1
    已完成第1圆球的第2个棱形任务 |  ThreadName=RxNewThreadScheduler-1
Main2Activity: 已完成第2圆球的第1个棱形任务 |  ThreadName=RxNewThreadScheduler-2
Main2Activity: 已完成第3圆球的第1个棱形任务 |  ThreadName=RxNewThreadScheduler-3
Main2Activity: 已完成第3圆球的第2个棱形任务 |  ThreadName=RxNewThreadScheduler-3
Main2Activity: 已完成第2圆球的第2个棱形任务 |  ThreadName=RxNewThreadScheduler-2

从打印的结果可以看到，FlatMap，首先是从1到3，即从左到右，执行任务的。其中，1、2、3又各自包含2个子任务。但是，很明显，未必就是2先执行完毕才执行3。反而是，2、3的第一个任务先完成，然后，才是2、3的第二个任务完成。

从这个例子，我们得出这样一个结论：FlatMap执行流程是：
先将所有一级任务，平铺成所有二级任务。再依照，从左到右到执行次序，执行任务。但是，任务成功的回调，却不是从左到右的。而是，谁先完成谁先回调，这样，有的任务，可能会因耗时而慢回调。从而导致，先执行，后回调的现象，简言之，即：执行次序是一定的，完成次序是不确定的。

ObservableSource是Observable的基类。

通过上面的代码可以看出，map 与 flatMap 这两个操作符的共同点在于，他们都是把一个对象转换为另一个对象，但须注意以下这些特点:

  1. flatMap 返回的是一个Observable对象，而 map 返回的是一个普通转换后的对象。
  2. flatMap 返回的Observable对象并不是直接发送到Subscriber的回调中，而是重新创建一个Observable对象，并激活这个Observable对象，使之开始发送事件；而 map 变换后返回的对象直接发到Subscriber回调中。
  3. flatMap 变换后产生的每一个Observable对象发送的事件，最后都汇入同一个Observable，进而发送给Subscriber回调。
  4. map返回类型 与 flatMap 返回的Observable事件类型，可以与原来的事件类型一样。
  5. 可以对一个Observable多次使用 map 和 flatMap。

鉴于 flatMap 自身强大的功能，这常常被用于 嵌套的异步操作，例如嵌套网络请求。传统的嵌套请求，一般都是在前一个请求的 onSuccess() 回调里面发起新的请求，这样一旦嵌套多个的话，缩进就是大问题了，而且严重的影响代码的可读性。而RxJava嵌套网络请求仍然通过链式结构，保持代码逻辑的清晰！

以下为结合OkHttp3的网络请求示例:

        Observable.create(new ObservableOnSubscribe() {

            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                Request request = new Request.Builder()
                        .url("http://api.avatardata.cn/MobilePlace/LookUp?key=ec47b85086be4dc8b5d941f5abd37a4e&mobileNumber=13021671512")
                        .get()//默认就是GET请求，可以不写
                        .build();

                Call call = new OkHttpClient().newCall(request);
                Response response = call.execute();
                emitter.onNext(response);
            }
        })
        .flatMap(new Function>() {
            @Override
            public ObservableSource apply(Response response) throws Exception {
                if (response.isSuccessful()) {
                    ResponseBody body = response.body();
                    if (body != null) {
                        return Observable.just(body.string());
                    }
                }
                return null;
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeOn(Schedulers.io())
        .subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                Toast.makeText(Main2Activity.this,s,Toast.LENGTH_SHORT).show();
            }
        });
    }

效果图:

Android-0.RxJava2简介_第4张图片

 

RxJava 其他常用操作符

 

1.from系列

接收一个集合作为输入，然后每次输出一个元素给subscriber,对应有fromIterable,fromArray。

 List list = Arrays.asList(1,2,3,4,5);
        Observable.fromIterable(list)
        .subscribe(new Consumer() {
            @Override
            public void accept(Integer number) throws Exception {
                Log.i(TAG, "number:" + number);
            }
        });

注意：如果from里面执行了耗时操作，即使使用了subscribeOn(Schedulers.io())，仍然是在主线程执行，可能会造成界面卡顿甚至崩溃，所以耗时操作还是使用Observable.create(…)。
 

2.just

接收一个可变参数作为输入，最终也是生成数组，调用from系列的fromArray，然后每次输出一个元素给subscriber。

// Observable.just(T... params)，params的个数为1 ~ 10
        Observable.just(1, 2, 3, 4, 5)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer number) throws Exception {
                        Log.i(TAG, "number:" + number);
                    }
                });

 

3.filter

条件过滤，去除不符合某些条件的事件。举个栗子:

        Observable.fromArray(1, 2, 3, 4, 5)
                .filter(new Predicate() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer % 2 == 0;// 偶数返回true，则表示剔除奇数，留下偶数
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer number) throws Exception {
                        Log.i(TAG, "number:" + number);
                    }
                });

输出：

01-04 07:17:34.503 4730-4730/com.hgy.rxjavademo I/Main2Activity: number:2
01-04 07:17:34.504 4730-4730/com.hgy.rxjavademo I/Main2Activity: number:4

 

4.take

最多发送的事件数。

        Observable.fromArray(1, 2, 3, 4, 5)
                .take(3) // 最多调用onNext三次
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer number) throws Exception {
                        Log.i(TAG, "number:" + number);
                    }
                });

输出：

number:1
number:2
number:3

 

5.doOnNext

在处理下一个事件之前要做的事。

                Observable.fromArray(1, 2, 3, 4, 5)
                .doOnNext(new Consumer() {// 
                    @Override
                    public void accept(Integer number) throws Exception {
                        Log.i(TAG, "hahcode = " + number.hashCode() + "");
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer number) throws Exception {
                        Log.i(TAG, "number:" + number);
                    }
                });

输出：

    hahcode = 1
    number:1
    hahcode = 2
    number:2
    hahcode = 3
    number:3
    hahcode = 4
    number:4
    hahcode = 5
    number:5

调用流程是onNext-->doOnNext-->subscribe。
 

6.debounce

防抖。简单的说，就是在特定的时间间隔中只有一个事件发送是有效的，其余的发送都无效，发送完事件后，重新计算时间间隔。debounce可以指定这个时间间隔！

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1); // skip
                Thread.sleep(400);
                emitter.onNext(2); // deliver
                Thread.sleep(505);
                emitter.onNext(3); // skip
                Thread.sleep(100);
                emitter.onNext(4); // deliver
                Thread.sleep(605);
                emitter.onNext(5); // deliver
                Thread.sleep(510);
                emitter.onComplete();
            }
        })
        .debounce(500, TimeUnit.MILLISECONDS)// 设置时间为0.5秒
        .subscribe(new Consumer(){
            @Override
            public void accept(Integer number) throws Exception {
                Log.i(TAG, "number:" + number);
            }
        });

输出：

01-04 07:40:45.605 5163-5187/com.hgy.rxjavademo I/Main2Activity: number:2
01-04 07:40:46.214 5163-5187/com.hgy.rxjavademo I/Main2Activity: number:4
01-04 07:40:46.821 5163-5187/com.hgy.rxjavademo I/Main2Activity: number:5

部分在间隔内的onNext被忽略了。

关键看被观察者这块：

1.事件1发送后休眠了400毫秒后就会发送事件2，小于500毫秒，重新计时。
2.事件2发出后休眠了505毫秒，超过了500毫秒，所以事件2被发射成功。
3.事件3发出后休眠了100毫秒就会发送事件4，所以事件3被遗弃。
4.事件4发出后休眠了605毫秒，超过了500毫秒，所以事件4被发射成功。
5.事件5发出后0.5秒内也没有再发出别的事件，所以最终事件5也被发射成功。

类似一个弹簧，如果一个事件相当于挤压它一下的话，它回到初始状态需要一段时间，那如果一直有事件不断的挤压它，那它一直回不到初始状态，就一个事件也弹不出来。一旦有一段时间里面没有人挤压它，他就把最后一个弹出来了。周而复始。

 

7.merge

用于合并两个Observable为一个Observable。输出顺序不固定。

 final String[] aStrings = {"A1", "A2", "A3", "A4"};
        final String[] bStrings = {"B1", "B2", "B3"};

        final Observable aObservable = Observable.fromArray(aStrings);
        final Observable bObservable = Observable.fromArray(bStrings);

        Observable.merge(aObservable,bObservable)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.i(TAG, s);
                    }
                });

输出：

  A1 A2 A3 A4 B1 B2 B3

合并的Observable类型不一定相同，如果不同，则以Serializable表示

        final String[] aStrings = {"A1", "A2", "A3", "A4"};
        final Observable aObservable = Observable.fromArray(aStrings);
        final Observable bObservable = Observable.fromArray(1,2,3);

        Observable.merge(aObservable,bObservable)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Serializable serializable) throws Exception {
                        Log.i(TAG, serializable.toString());
                    }
                });

输出：

  A1 A2 A3 A4 1 2 3

 

8.concat

顺序执行多个Observable，个数为1 ~ 9。注意是顺序执行，而前面的merge输出顺序不固定。
代码和merge类似，就不再贴了。

 

9.compose

与 flatMap 类似，都是进行变换，返回Observable对象，激活并发送事件。

  1. compose 是唯一一个能够从数据流中得到原始Observable的操作符，所以，那些需要对整个数据流产生作用的操作（比如，subscribeOn()和observeOn()）需要使用 compose 来实现。相较而言，如果在flatMap()中使用subscribeOn()或者observeOn()，那么它仅仅对在 flatMap 中创建的Observable起作用，而不会对剩下的流产生影响。
  2. compose 是对 Observable 整体的变换，换句话说， flatMap 转换Observable里的每一个事件，而 compose 转换的是整个Observable数据流。
  3. flatMap 每发送一个事件都创建一个 Observable，所以效率较低。而 compose 操作符只在主干数据流上执行操作。
 List list = Arrays.asList(1, 2, 3);
        Observable.fromIterable(list)
                .compose(new MyTransformer());

    class MyTransformer implements ObservableTransformer{
        @Override
        public ObservableSource apply(Observable upstream) {
            return upstream
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    }

如上，我们在MyTransformer中封装了常用的subscribeOn+observeOn操作，通过 .compose(new MyTransformer())我们可以让所有的Observable来重用。

 

10.first

只发送符合条件的第一个事件。

 

11.timer

可以做定时操作，换句话讲，就是延迟执行。事件间隔由timer控制。举个栗子：两秒后输出
“Hello World！”

 Observable.timer(2,TimeUnit.MILLISECONDS)
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.i(TAG, "Hello World!");
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

 

12.interval

定时的周期性操作，与timer的区别就在于它可以重复操作。事件间隔由interval控制。举个栗子：每隔两秒输出 “Hello World！”, 将前面的代码中timer换成interval，不贴代码了。

 

13.throttleFirst

与debounce类似，也是时间间隔太短，就丢弃事件。可以用于防抖操作。
允许设置一个时间长度，之后它会发送固定时间长度内的第一个事件，而屏蔽其它事件，在间隔达到设置的时间后，可以再发送下一个事件。

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1); // skip
                Thread.sleep(400);
                emitter.onNext(2); // deliver
                Thread.sleep(505);
                emitter.onNext(3); // skip
                Thread.sleep(100);
                emitter.onNext(4); // deliver
                Thread.sleep(605);
                emitter.onNext(5); // deliver
                Thread.sleep(510);
                emitter.onComplete();
            }
        })
        .throttleFirst(500, TimeUnit.MILLISECONDS)// 设置时间为0.5秒
        .subscribe(new Consumer(){
            @Override
            public void accept(Integer number) throws Exception {
                Log.i(TAG, "number:" + number);
            }
        });

输出：

01-04 09:38:02.183 5750-5750/com.hgy.rxjavademo I/Main2Activity: number:1
01-04 09:38:03.092 5750-5750/com.hgy.rxjavademo I/Main2Activity: number:3
01-04 09:38:03.802 5750-5750/com.hgy.rxjavademo I/Main2Activity: number:5

和debounce的输出结果可以做个类比。

 

14.Single

Single与Observable类似，相当于是他的精简版。订阅者回调的不是OnNext/OnError/onCompleted，而是回调OnSuccess/OnError。

        Single.create(new SingleOnSubscribe() {

            @Override
            public void subscribe(SingleEmitter emitter) throws Exception {
                emitter.onSuccess("Hello");
            }
        })
        .subscribe(new SingleObserver() {

            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(Object o) {
                Log.i(TAG, o.toString());
            }

            @Override
            public void onError(Throwable e) {

            }
        });
 
  
 
 
  
15.Subject
 
  
Subject这个类，既是Observable又是Observer，啥意思呢？就是它自身既是事件的生产者，又是事件的消费者，相当于自身是一条管道，从一端进，又从另一端出。举个栗子：PublishSubject
 
  
        Subject subject = PublishSubject.create();

        // 1.由于Subject是Observable，所以进行订阅
        subject.subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                Log.i(TAG, o.toString());
            }
        });

        // 2.由于Subject同时也是Observer，所以可以调用onNext发送数据
        subject.onNext("world");

 
  
 
 
  
RxJava取消订阅
 
  
Disposable可以通过以下来获取：
 1.subscribe 时返回了 Disposable:
 
  
 Disposable disposable =  Observable.just(1,2,3).subscribe(...);

 
  
2.从 observer 的 onSubscribe 中获取:
 
  
 .subscribe(new Observer() {
                    private Disposable disposable;

                    @Override
                    public void onSubscribe(Disposable d) {
                        disposable = d;
                    }

 
  
然后直接调用 disposable.dispose();取消订阅。
 但是，如果有很多个数据源，那岂不是要取消很多次？当然不是的，可以利用CompositeDisposable ， 相当于一个 Disposable 集合。
 
  
        CompositeDisposable list = new CompositeDisposable();
        list.add(disposable1);
        list.add(disposable2);
        // 统一调用,就可以把所有的订阅都取消
        list.dispose();

 
  
当然，也可以使用第三方库，如rxlifecycle
  
 
  
总结
 
  
     
   
  1. 首先是创建被观察者，可以用Observable的create/just/from等方法来创建。
    2.  
   
  2. 通过filter/debounce等操作符，进行自定义事件过滤。
    3.  
   
  3. 通过Schedules进行事件发送和订阅的线程控制，也就是subscribeOn() 和 observeOn()。
    4.  
   
  4. 通过map/flatMap/compose等操作符，进行事件的变换。
    5.  
   
  5. 调用subscribe进行事件订阅。
    6.  
   
  6. 最后，不要忘了对订阅者生命周期的控制，不用的时候，记得调用dispose()，以免引发内存泄漏。
    7.  
  
 
  
参考：
 https://blog.csdn.net/yyh352091626/article/details/53304728
 https://gank.io/post/560e15be2dca930e00da1083
 https://www.jianshu.com/p/d53463e1c3d6
 https://www.cnblogs.com/zhujiabin/p/8183827.html
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android)

        

            

                
    
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • Android实现监听事件的方法
                        Amy木婉清

                        
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    
                    
    • 
                    
  • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    
                    
    • 
                    
  • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    
                    
    • 
                    
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    
                    
    • 
                    
  • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
                        计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
                        
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    
                    
    • 
                    
  • android ndk 开发jni调用对象方法，数组参数
                        wulongkou
开发问题安卓的事ndkandroidstudiojni
                        
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
    
                    
    • 
                    
  • Android jni中数组参数的传递方式
                        lokeyme
Andriodandroid开发JNINDKjavac语言
                        
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
    
                    
    • 
                    
  • 1-1.Jetpack 之 Navigation 简单编码模板
                        我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
                        
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
    
                    
    • 
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Android干净架构MVI模板使用指南
                        井美婵Toby

                        
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
    
                    
    • 
                    
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    
                    
    • 
                    
  • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    
                    
    • 
                    
  • android进阶之光！Android面试必备的集合源码详解，系列篇
                        程序员Sunbu
程序员Android
                        
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
    
                    
    • 
                    
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
                        egrhef
程序员androidjava开发语言
                        
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
    
                    
    • 
                    
  • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    
                    
    • 
                    
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
                        仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
                        
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
    
                    
    • 
                    
  • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    
                    
    • 
                    
  • （小白入门）Windows环境下搭建React Native Android开发环境
                        码农老黑
前端ReactNative移动开发Androidstudio
                        
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    
                    
    • 
                    
  • Android Dialog圆角设置无效的问题
                        ly969434341
android
                        
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
    
                    
    • 
                    
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活
                        技术无疆
Androidandroiduiandroidstudioandroid-studiojavaandroidx
                        
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
    
                    
    • 
                    
  • Android界面特效全汇总
                        小飞鹤
Android开发详解android
                        
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
    
                    
    • 
                                
  • 用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类）
                                    AdyZhang
POJOeclipseHibernateMiddleGenIDE
                                    
    推荐:MiddlegenIDE插件,   是一个Eclipse   插件.     用它可以直接连接到数据库,   根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件!     今天开始试着使用
    
                                
    • 
                                
  • .9.png
                                    Cb123456
android
                                    
      “点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 
　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。 
　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
    
                                
    • 
                                
  • 算法的效率
                                    天子之骄
算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
                                    
    算法的效率 
效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。 
  
以下是我的学习笔记： 
  
1.求值与霍纳法则，即为秦九韶公式。 
  
2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。 
    
                                
    • 
                                
  • java数据结构
                                    何必如此
java数据结构
                                    
    Java 数据结构 
 
Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 
 
枚举（Enumeration） 
位集合（BitSet） 
向量（Vector） 
栈（Stack） 
字典（Dictionary） 
哈希表（Hashtable） 
属性（Properties） 
以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
    
                                
    • 
                                
  • MybatisHelloWorld
                                    3213213333332132

                                    
    
//测试入口TestMyBatis   
package com.base.helloworld.test;

import java.io.IOException;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibat
    
                                
    • 
                                
  • Java|urlrewrite|URL重写|多个参数
                                    7454103
javaxmlWeb工作
                                    
     个人工作经验！ 如有不当之处，敬请指点    
1.0  web -info 目录下建立     urlrewrite.xml  文件 类似如下： 
<?xml version="1.0" encoding="UTF-8" ?>  
  <!DOCTYPE u
    
                                
    • 
                                
  • 达梦数据库+ibatis
                                    darkranger
sqlmysqlibatisSQL Server
                                    
    --插入数据方面 
 
如果您需要数据库自增... 
那么在插入的时候不需要指定自增列. 
 
如果想自己指定ID列的值, 那么要设置 
set identity_insert  数据库名.模式名.表名; 
----然后插入数据; 
example: 
create table zhabei.test( 
id bigint identity(1,1) primary key, 
nam
    
                                
    • 
                                
  • XML 解析 四种方式
                                    aijuans
android
                                    
    XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。   
 
  
 
    
 
XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object 
    
                                
    • 
                                
  • spring中配置文件占位符的使用
                                    avords

                                    
    1.类 
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
    
                                
    • 
                                
  • 前端工程化-公共模块的依赖和常用的工作流
                                    bee1314
webpack
                                    
    题记： 一个人的项目，还有工程化的问题嘛？       我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？   你真的想这样嘛？       var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。     
    
                                
    • 
                                
  • 上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？
                                    bijian1013
项目管理沟通IT职业规划
                                    
    问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应 
        正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。 
  
Eno-Bea回答，注重感受，不一定是别人的 
        虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
    
                                
    • 
                                
  • TortoiseSVN，过滤文件
                                    征客丶
SVN
                                    
    环境： 
TortoiseSVN 1.8 
 
配置： 
在文件夹空白处右键 
选择  TortoiseSVN -> Settings 
在 Global ignote pattern 中添加要过滤的文件： 
多类型用英文空格分开 
*name ： 过滤所有名称为 name 的文件或文件夹 
*.name ： 过滤所有后缀为 name 的文件或文件夹 
 
 
 
--------
    
                                
    • 
                                
  • 【Flume二】HDFS sink细说
                                    bit1129
Flume
                                    
    1. Flume配置 
  
a1.sources=r1  
a1.channels=c1  
a1.sinks=k1  

###Flume负责启动44444端口
  
a1.sources.r1.type=avro  
a1.sources.r1.bind=0.0.0.0  
a1.sources.r1.port=44444  
a1.sources.r1.chan
    
                                
    • 
                                
  • The Eight Myths of Erlang Performance
                                    bookjovi
erlang
                                    
    erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 
里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html 
  
  
Myth: Funs are sl
    
                                
    • 
                                
  • java多线程网络传输文件(非同步)-2008-08-17
                                    ljy325
java多线程socket
                                    
    利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。 
使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 
客户端: 
修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-模板方法模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
    
                                
    • 
                                
  • 配置心得
                                    chenyu19891124
配置
                                    
    时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。 
作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。 
做了一年的配置管理给自总结下： 
1.改变 
从一个以前对配置毫无
    
                                
    • 
                                
  • 对“带条件选择的并行汇聚路由问题”的再思考
                                    comsci
算法工作软件测试嵌入式领域模型
                                    
    2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
    
                                
    • 
                                
  • Oracle 10g 的clusterware 32位 下载地址
                                    daizj
oracle
                                    
    Oracle 10g 的clusterware 32位 下载地址 
 
http://pan.baidu.com/share/link?shareid=531580&uk=421021908 
 
 
http://pan.baidu.com/share/link?shareid=137223&uk=321552738 
 
http://pan.baidu.com/share/l
    
                                
    • 
                                
  • 非常好的介绍：Linux定时执行工具cron
                                    dongwei_6688
linux
                                    
    Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。 
新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
    
                                
    • 
                                
  • Yii assets目录生成及修改
                                    dcj3sjt126com
yii
                                    
    assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 
assets设置对应的方法位置 \framework\web\CAssetManager.php 
  
assets配置方法 在m
    
                                
    • 
                                
  • mac工作软件推荐
                                    dcj3sjt126com
mac
                                    
    mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。 
我为什么要要iterm2 
切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： 
 
 * 兼容性好，远程服务器 vi 什么的低版本能很好兼
    
                                
    • 
                                
  • Memcached(三)、封装Memcached和Ehcache
                                    frank1234
memcachedehcachespring ioc
                                    
    本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 
cache.xml 
 
<?xml version="1.0" encoding="UTF-8"?>

    
                                
    • 
                                
  • Remove Duplicates from Sorted List II
                                    hcx2013
remove
                                    
    Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. 
For example,Given 1->2->3->3->4->4->5,
    
                                
    • 
                                
  • Spring4新特性——注解、脚本、任务、MVC等其他特性改进
                                    jinnianshilongnian
spring4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • MySQL安装文档
                                    liyong0802
mysql
                                    
      工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。 
  安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。 
  Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
    
                                
    • 
                                
  • 使用VS2010构建HotSpot工程
                                    p2p2500
HotSpotOpenJDKVS2010
                                    
    1. 下载OpenJDK7的源码： 
     
http://download.java.net/openjdk/jdk7 
     
http://download.java.net/openjdk/ 
     
2. 环境配置 
    ▶
    
                                
    • 
                                
  • Oracle实用功能之分组后列合并
                                    seandeng888
oracle分组实用功能合并
                                    
    1       实例解析  
由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下： 
表test 数据如下： 
ID,SUBJECTCODE,DIMCODE,VALUE 
1&nbs
    
                                
    • 
                                
  • Java定时任务注解方式实现
                                    tuoni
javaspringjvmxmljni
                                    
    Spring 注解的定时任务，有如下两种方式： 
第一种： 
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

 xmlns:xsi="http
    
                                
    • 
                                
  • 11大Java开源中文分词器的使用方法和分词效果对比
                                    yangshangchuan
word分词器ansj分词器Stanford分词器FudanNLP分词器HanLP分词器
                                    
    本文的目标有两个： 
1、学会使用11大Java开源中文分词器 
2、对比分析11大Java开源中文分词器的分词效果 
本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 
11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： 
/**
 * 获取文本的所有分词结果, 对比
    
                                
    •