2016年10月_new_abc

12月 11月 10月 09月 08月 07月 06月 05月 03月

原创 Rxjava(过滤类)-Debounce

仅在过了一段指定的时间还没发射数据时才发射一个数据demoObservable.create(new Observable.OnSubscribe() { @Override public void call(Subscriber subscriber) { try {

2016-10-31 22:32:04 840

原创 Rxjava(过滤类)-Distinct

抑制（过滤掉）重复的数据项Distinct 的过滤规则是：只允许还没有发射过的数据项通过。demo Observable.just("a", "a", "b", "c", "a", "b") .distinct() .subscribe(new Action1() {

2016-10-31 21:48:42 2333

原创 Rxjava(过滤类)-ElementAt

只发射第N项数据demoObservable.range(1, 10).elementAt(2).subscribe(new Action1() { @Override public void call(Integer integer) { System.out.println(integer);

2016-10-31 18:02:39 751

原创 Rxjava(过滤类)-take

只发射前面的N项数据demo Observable.range(1, 10).take(2).subscribe(new Action1() { @Override public void call(Integer integer) { System.out.println(integer);

2016-10-31 17:45:25 2435

原创 Rxjava(过滤类)-skipLast

抑制Observable发射的后N项数据demo Observable.range(1, 10).skipLast(2).subscribe(new Action1() { @Override public void call(Integer integer) { System.out.println

2016-10-31 17:33:34 684

原创 Rxjava(过滤类)-Skip

抑制Observable发射的前N项数据,使用 Skip操作符，你可以忽略Observable'发射的前N项数据，只保留之后的数据。demo: Observable.range(1, 10).skip(2).subscribe(new Action1() { @Override public void call(In

2016-10-31 17:25:38 1072

原创 Rxjava(过滤类)-Last

只发射最后一项（或者满足某个条件的最后一项）数据bservable.range(1, 10).last().subscribe(new Action1() { @Override public void call(Integer integer) { System.out.println(integer);

2016-10-31 17:10:26 1055

原创 Rxjava(过滤类)-Filter

只发射通过了谓词测试的数据项 Observable.range(1, 10).filter(new Func1() { @Override public Boolean call(Integer integer) { return integer % 2 == 0; }

2016-10-31 16:35:16 2324

原创 Rxjava(变换类)-Window

定期将来自原始Observable的数据分解为一个Observable窗口，发射这些窗口，而不是每次发射一项数据Window和 Buffer类似，但不是发射来自原始Observable的数据包，它发射的是 Observables，这些Observables中的每一个都发射原始Observable数据的一个子集，最后发射一个onCompleted 通知。 demo

2016-10-31 16:16:11 1899

原创 Rxjava(变换类)-GroupBy

将一个Observable分拆为一些Observables集合，它们中的每一个发射原始Observable的一个子序列,哪个数据项由哪一个Observable发射是由一个函数判定的，这个函数给每一项指定一个Key，Key相同的数据会被同一个Observable发射.demoObservable.range(1, 8).groupBy(new Func1() {

2016-10-31 15:25:17 3218

原创 Rxjava(变换类)-scan

连续地对数据序列的每一项应用一个函数，然后连续发射结果我们看一个demo Observable.range(1, 10).scan(new Func2() { @Override public Integer call(Integer integer, Integer integer2) { retur

2016-10-31 11:49:11 792

原创 Rxjava(变换类)-Buffer

定期收集Observable的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值。Buffer 操作符将一个Observable变换为另一个，原来的Observable正常发射数据，变换产生的Observable发射这些数据的缓存集合。Buffer 操作符在很多语言特定的实现中有很多种变体，它们在如何缓存这个问题上存在区别。注意：如果原来的Observa

2016-10-28 14:41:48 745

原创 Rxjava(Subject)-一个综合例子

这个例子来自http://blog.piasy.com/AdvancedRxJava/2016/10/03/subjects-part-1/package com.test;import rx.Observable;import rx.Observer;import rx.functions.Action1;import rx.functions.Func1;import rx.o

2016-10-28 11:25:40 899

原创 Rxjava(Subject)-SerializedSubject(线程安全)--demo

demopackage com.test;import rx.functions.Action1;import rx.subjects.PublishSubject;import rx.subjects.SerializedSubject;/** * Created by leaves on 2016/10/28. */public class MultiThreadTest

2016-10-28 11:17:49 2156

原创 Rxjava(Subject)-ReplaySubject--代码分析

先看一下类图结构然后，看一下create public static ReplaySubject create() { return create(16); }这里默认把容量设置为16，也即能保存到最新的16个状态 public static ReplaySubject create(int capacity) { if (

2016-10-27 23:23:10 1052

原创 Rxjava(Subject)-ReplaySubject--demo

ReplaySubject会发射所有来自原始Observable的数据给观察者，无论它们是何时订阅的。也有其它版本的ReplaySubject，在重放缓存增长到一定大小的时候或过了一段时间后会丢弃旧的数据（原始Observable发射的）。如果你把ReplaySubject当作一个观察者使用，注意不要从多个线程中调用它的onNext方法（包括其它的on系列方法），这可能导致同时（非顺序）

2016-10-27 22:20:58 685

原创 Rxjava(Subject)-PublishSubject--代码分析

先看下类图我们看一下它的创建： public static PublishSubject create() { return new PublishSubject(new PublishSubjectState()); }创建了一个PublishSubjectState然后看下onNext public void onN

2016-10-27 18:07:10 2208

原创 Rxjava(Subject)-PublishSubject--demo

PublishSubject只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者。需要注意的是，PublishSubject可能会一创建完成就立刻开始发射数据（除非你可以阻止它发生），因此这里有一个风险：在Subject被创建后到有观察者订阅它之前这个时间段内，一个或多个数据可能会丢失。如果要确保来自原始Observable的所有数据都被分发，你需要这样做：或者使用C

2016-10-27 17:55:09 2689

原创 Rxjava(Subject)-BehaviorSubject--代码分析

还是把demo贴过来BehaviorSubject s = BehaviorSubject.create(555); s.subscribe(new Action1() { @Override public void call(Integer integer) { System.out.printl

2016-10-27 16:37:52 1065

原创 Rxjava(Subject)-BehaviorSubject--demo

当观察者订阅BehaviorSubject时，它开始发射原始Observable最近发射的数据（如果此时还没有收到任何数据，它会发射一个默认值），然后继续发射其它任何来自原始Observable的数据。然而，如果原始的Observable因为发生了一个错误而终止，BehaviorSubject将不会发射任何数据，只是简单的向前传递这个错误通知。我们来看下demo

2016-10-27 16:04:09 1075

原创 Rxjava(Subject)-AsyncSubject--代码分析

首先我们来看下它的类结构图从demo分析我们的代码 AsyncSubject subject = AsyncSubject.create(); subject.subscribe(new Action1() { @Override public void call(Integer integer) {

2016-10-27 15:47:53 830

原创 Rxjava(Subject)-AsyncSubject--demo

Subject可以看成是一个桥梁或者代理，在某些ReactiveX实现中（如RxJava），它同时充当了Observer和Observable的角色。因为它是一个Observer，它可以订阅一个或多个 Observable；又因为它是一个Observable，它可以转发它收到(Observe)的数据，也可以发射新的数据。一个AsyncSubject只在原始Observable完成后，发射来

2016-10-27 15:00:35 1178

原创 Rxjava(变换类)-concatMap

demo Observable.from(aa).concatMap(new Func1>() { @Override public Observable call(Integer number) { return Observable.just(number * number).subscrib

2016-10-27 11:45:02 1679

原创 Rxjava(变换类)--FlatMap2

demo ArrayList aa= new ArrayList<>(Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 10)); Observable.from(aa).flatMap(new Func1>() { @Override public Observable call(Int

2016-10-26 23:01:54 925

原创 Rxjava(线程类)--subscribeOn原理

实例： System.out.println("<<<<<< main threadid = " + Thread.currentThread().getId()); Observable.just(1).doOnSubscribe(new Action0() { @Override public void call

2016-10-26 12:33:18 798

原创 Rxjava(其他)--doOnSubscribe原理

doOnSubscribe一般用于执行一些初始化操作，我们看其实现原理demo Observable.just(1).doOnSubscribe(new Action0() { @Override public void call() { System.out.println("<<<<<<subsc

2016-10-26 12:18:52 6893

原创 Rxjava(线程类)--observeOn原理

实例代码如下： Observable.just(1).observeOn(Schedulers.from(JobExecutor.getInstance())).subscribe(new Action1() { @Override public void call(Integer integer) {

2016-10-26 11:25:30 746

原创 Rxjava(线程类)--observeOn和subscribeOn实例

observeOn作用于该操作符之后操作符直到出现新的observeOn操作符 System.out.println("<<<<<< main threadid = " + Thread.currentThread().getId()); Observable.just(1).map(new Func1() { @Override

2016-10-26 10:58:21 782

原创 Rxjava(变换类)--FlatMap

FlatMap 将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的ObservableFlatMap 操作符使用一个指定的函数对原始Observable发射的每一项数据执行变换操作，这个函数返回一个本身也发射数据的Observable，然后FlatMap 合并这些Observables发射的数据，最后将合并后

2016-10-25 18:11:47 1569

原创 Rxjava(变换类)--map

对Observable发射的每一项数据应用一个函数，执行变换操作 Observable.just(1).map(new Func1() { @Override public Integer call(Integer integer) { return integer + 1;

2016-10-25 17:41:19 550

原创 Rxjava(创建类)--timer

创建一个Observable，它在一个给定的延迟后发射一个特殊的值 Observable.timer(10, TimeUnit.SECONDS).subscribe(new Action1() { @Override public void call(Long aLong) { log(aLong + ""

2016-10-25 17:15:04 760

原创 Rxjava(创建类)--start

Async.start(new Func0() { @Override public String call() { String s = "333333333"; return s + "4444444444"; } }).subscribe(n

2016-10-25 17:07:03 432

原创 Rxjava(创建类)--Repeat

创建一个发射特定数据重复多次的Observable

2016-10-25 14:36:23 904

原创 Rxjava(创建类)--Range

创建一个发射特定整数序列的Observable,Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。RxJava将这个操作符实现为range函数，它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。Observable.range(10, 10).subsc

2016-10-24 18:07:22 603

原创 Rxjava(创建类)--Interval

创建一个按固定时间间隔发射整数序列的Observable，它接受一个表示时间间隔的参数和一个表示时间单位的参数。 Observable.interval(10, TimeUnit.SECONDS).subscribe(new Action1() { @Override public void call(Long aLong)

2016-10-24 18:00:07 996

原创 Rxjava(创建类)--error

error创建一个不发射数据以一个错误终止的Observable Observable.error(new Exception("ddddd")).subscribe(new Observer() { @Override public void onNext(String s) { log("onNe

2016-10-24 17:11:13 375

原创 Rxjava(创建类)--Never

Never创建一个不发射数据也不终止的Observable Observable.never().subscribe(new Observer() { @Override public void onNext(String s) { log("onNext:" + s);

2016-10-24 17:03:41 700

原创 Rxjava(创建类)--Empty

创建一个不发射任何数据但是正常终止的ObservableObservable.empty().subscribe(new Observer() { @Override public void onNext(String s) { log("onNext:" + s); }

2016-10-24 16:51:46 1716

原创 Rxjava(创建类)--defer

还是先看文档上面的直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的ObservableDefer 操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个 Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个 Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。在

2016-10-24 16:02:37 514

原创 Rxjava(创建类)--from

from的参数只能是数组或者Iterable或者Future等，不能是基本类型等，我们看一下下面这个例子 Integer[] items2 = { 0, 1, 2, 3, 4, 5 }; Observable myObservable =Observable.from(items2); Subscriber mySubscriber = new S

2016-10-21 16:24:24 611