【Android】Rxjava操做符系列（一）
今天开始Rxjava的学习，废话很少说了，开始撸操做符了java
1.Create
做用：经过调用观察者的方法从头建立一个Observable.web
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
subscriber.onNext(1);
subscriber.onNext(2);
subscriber.onNext(3);
subscriber.onNext(4);
subscriber.onCompleted();
}
});
Subscription subscription = observable.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","value = "+integer.toString());
}
});
结果：数组
2.defer
做用：只有当订阅者订阅才建立Observable，为每一个订阅建立一个新的Observable.缓存
int i = 12;
Observable deferObservable = Observable.defer(new Func0<Observable<Integer>>() {
@Override
public Observable<Integer> call() {
return Observable.just(i);
}
});
i = 15;
Subscription defersub = deferObservable.subscribe(new Subscriber() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Object o) {
Log.e("rxjava","defer value = "+o.toString());
}
});
结果：ide
3.from
做用：from操做符能够转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据.svg
Observable<Integer> observable = Observable.from(new Integer[]{1, 2, 3, 4, 5});
Subscription sub = observable.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","from value = "+integer.toString());
}
});
结果：函数
4.just
做用：Just相似于From，可是From会将数组或Iterable的数据取出而后逐个发射，而Just只是简单的原样发射，将数组或Iterable当作单个数据.学习
Subscription sub = Observable.just(1, 2, 3, 4, 5)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","just value = "+integer.toString());
}
});
结果：ui
5.range
做用：Range操做符发射一个范围内的有序整数序列，你能够指定范围的起始和长度.spa
Subscription sub = Observable.range(3, 5)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","range value = "+integer.toString());
}
});
结果：
6.repeat
做用：Repeat重复地发射数据。某些实现容许你重复的发射某个数据序列，还有一些容许你限制重复的次数.
Subscription sub = Observable.range(3, 5)
.repeat(2)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","repeat value = "+integer.toString());
}
});
结果：
7.timer
做用：timer建立一个Observable，它在一个给定的延迟后发射一个特殊的值0.
Subscription sub = Observable.timer(2, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Long>() {
@Override
public void call(Long value) {
Log.e("rxjava","timer value = "+value.toString());
}
});
结果：
8.interval
做用：建立一个按固定时间间隔发射整数序列的Observable,例子中没2秒输出一次，value大于5中止输出.
Observable.interval(2, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Long>() {
@Override
public void call(Long value) {
if (value > 5) {
sub.unsubscribe();
return;
}
Log.e("rxjava","interval value = "+value.toString());
}
});
结果：
9.buffer
做用：将源Observable变换一个新的Observable，这个新的Observable每次发射一组列表值而不是一个一个发射.
1.buffer(a,b)
Subscription sub = Observable.range(1,5).buffer(5,1)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<List<Integer>>() {
@Override
public void call(List<Integer> integers) {
Log.e("rxjava","interval value = "+integers.toString());
}
});
结果：
2.buffer(a)
Subscription sub = Observable.range(1,5).buffer(2)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<List<Integer>>() {
@Override
public void call(List<Integer> integers) {
Log.e("rxjava","buffer value = "+integers.toString());
}
});
结果：
10.flatmap
做用：flatmap把一个Observable变成多个Observable，而后把获得的多个Obervable的元素一个个的发射出去,下面的例子是把输入三个teacher对象，最后以此输出每一个teacher的name的hashcode值.
Subscription sub = Observable.just(new Teacher("张三",18),new Teacher("李四",23),new Teacher("王五",21))
.flatMap(new Func1<Teacher, Observable<String>>() {
@Override
public Observable<String> call(Teacher teacher) {
return Observable.just(teacher.getName().hashCode()+"");
}
})
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.e("rxjava","flatmap value = "+s);
}
});
结果：
11.groupby
做用：对数据按照必定个规则进行分组
Subscription sub = Observable.range(1, 10).groupBy(new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
return (integer % 2 == 0) ? "偶数组" : "奇数组";
}
}).subscribe(new Action1<GroupedObservable<String, Integer>>() {
@Override
public void call(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) {
stringIntegerGroupedObservable.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","groupby key = "+stringIntegerGroupedObservable.getKey()+" value = "+integer.toString());
}
});
}
});
结果：
12.map
做用：Map操做符对原始Observable发射的每一项数据应用一个函数，而后返回一个发射这些结果的Observable，例子：打印老师列表对象的名字：
Subscription sub = Observable.just(new Teacher("张三",18),new Teacher("李四",23),new Teacher("王五",21))
//使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
.map(new Func1<Teacher, String>() {
@Override
public String call(Teacher i) {
String name = i.getName();//获取Student对象中的name
return name;//返回name
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.e("rxjava","map value = "+s);
}
});
结果：
map和flatmap的区别：map，是把发射对象转成另一个对象发射出去，flatMap, 是把发射对象转成另一个Observable,进而把这个Observable发射的对象发射出去；
13.scan
做用：sacn操做符是遍历源Observable产生的结果，再按照自定义规则进行运算，依次输出每次计算后的结果给订阅者，call 回掉第一个参数是上次的结算结果，第二个参数是当此的源observable的输入值。例子：1到5依次进行scan计算：
Subscription sub = Observable.range(1,5)
.scan(new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer sum, Integer inv) {
return sum+inv;
//计算顺序：sum一开始为0，0+1 输出1，此时sum为1，1+2 输出3，此时sum为3 3+3 输出6，以此类推
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer s) {
Log.e("rxjava","map value = "+s);
}
});
结果：
14.window
做用：window发射的是Observable而不是列表。下面展现了window()如何缓存3个数据项并把它们做为一个新的Observable发射出去.
Observable.range(1, 10).window(3).subscribe(new Action1<Observable<Integer>>() {
@Override
public void call(final Observable<Integer> obser) {
obser.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rxjava","window obser = "+obser+" value = "+integer.toString());
}
});
}
});
结果：
欲知后事如何，请看下回分解！