new_abc的专栏

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

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

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

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

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

just操作符跟Observable.create一样，同样是创建一个Observable,看一下just创建的流程。 public static Observable just(final T value) { return ScalarSynchronousObservable.create(value); }这里调用ScalarSynchronousObs

myObservable.subscribe(mySubscriber);我们看到是 被观察者 订阅 观察者 public final Subscription subscribe(Subscriber subscriber) { return Observable.subscribe(subscriber, this); }static Subscrip

Subscriber是一个抽象类，它实现了观察者接口Subscription接口方法已由Subscriber实现，所以我们只需要实现Observer接口 @Override public final void unsubscribe() { subscriptions.unsubscribe(); } /** * Indic

Create操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数让它的行为表现为一个Observable--恰当的调用观察者的onNext，onError和onCompleted方法。一个形式正确的有限Observable必须尝试调用观察者的onCompleted正好一次或者它的onError正好一次，而且此后不能再调用观察者的任何其它方法

上篇文章我们分析的是from参数只有一个，假设有多个，这里我们假设2个Observable myObservable =Observable.just("Hello, world!","ddd");我们看下有什么不一样 public static Observable just(T t1, T t2) { return from((T[])new Object[]

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

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

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

Observable.just(1, 2, 3, 4) .collect(() -> new ArrayList<Integer>(), new BiConsumer<ArrayList<Integer>, Integer>() { @Override ...

直接上demo Observable observable1 = Observable.interval(1, TimeUnit.SECONDS); Observable observable2 = Observable.interval(2, TimeUnit.SECONDS); Observable observable3 = Observa...

map和flatMap都是依赖传入的Function对数据进行变换但是1、返回值上面：map变换后可以返回任意值，而flatMap则只能返回ObservableSource类型2、变换后的输出：map只能进行一对一的变换，而flatMap则可以进行一对一，一对多，多对多的变换，具体的变换规则根据我们设置的变换函数mapper来定demoList<String&g...

1、创建类操作符返回一个具体的Observable,如just返回ObservableFromArray 它里面重写了subscribeActual2、Observable调用subscribe的时候会根据重写的回调方法Consumer，构建一个新的Observer(LambdaObserver),如果对应的方法没有，则使用默认的Consumer，如没有onError,则使用Functions....

通过一个函数将多个Observables的发射物结合到一起，基于这个函数的结果为每个结合体发 射单个数据项。Zip 操作符返回一个Obversable，它使用这个函数按顺序结合两个或多个Observables发射 的数据项，然后它发射这个函数返回的结果。它按照严格的顺序应用这个函数。它只发射与 发射数据项最少的那个Observable一样多的数据demo

合并多个Observables的发射物， Merge可能会让合并的Observables发射的数据交错（有一个类似的操作符 Concat不会让数 据交错，它会按顺序一个接着一个发射多个Observables的发射物看两个demoObservable.merge(Observable.create(new Observable.OnSubscribe() {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

这个例子来自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

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

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

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

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

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