学习资料
- ReactiveX/RxJava文档中文版
1. 变换操作符
作用：用于对Observable发射的数据进行变换
1.1 Buffer缓冲
定期收集Observable的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值
注意：如果原来的Observable发射了一个onError通知，Buffer会立即传递这个通知，而不是首先发射缓存的数据，即使在这之前缓存中包含了原始Observable发射的数据
1.1.1 buffer(count)
将原始Observable产生的数据以List非重叠的形式缓存，一次最多缓存count个，然后产生的新的Observable一次性将List发送出去
/**
* buffer(3)
* 缓存3个原始数据，存进List
*/
private static void bufferCount() {
Observable
.from(Stream.iterate(1, new UnaryOperator() {
@Override
public Integer apply(Integer integer) {
return integer + 1;
}
}).limit(30).collect(Collectors.toList()))
.buffer(3)
.subscribe(new Action1>() {
@Override
public void call(List integers) {
System.out.println(integers);
}
});
}
运行结果：
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10, 11, 12]
[13, 14, 15]
[16, 17, 18]
[19, 20, 21]
[22, 23, 24]
[25, 26, 27]
[28, 29, 30]
1.1.2 buffer(count , skip)
从原始的Observable的第一项数据开始进行缓存，发出了skip个数据后，将着skip个数据看作一组，从当前这组第一项数据开始，直到count个数据，存进List集合，由新的Observable发出。根据count，skip大小，会出现重叠或者间隙
count < skip ,出现间隙：
private static void bufferSkip() {
Observable
.from(Stream.iterate(1, new UnaryOperator() {
@Override
public Integer apply(Integer integer) {
return integer + 1;
}
}).limit(30).collect(Collectors.toList()))
//.buffer(3,2)//重叠
.buffer(3,5)//间隙
.subscribe(new Action1>() {
@Override
public void call(List integers) {
integers.forEach(new Consumer() {
@Override
public void accept(Integer integer) {
System.out.print(integer + " ");
}
});
}
});
}
运行结果：
1 2 3 6 7 8 11 12 13 16 17 18 21 22 23 26 27 28
每当收到5数据时，这5个数据就是一组的，就从第一个开始，将缓存的3个数据存进List，剩下2个就丢弃，这样就导致产生间隙
count > skip ，出现重叠：
...
.buffer(3,2)
...
运行结果：
1 2 3 3 4 5 5 6 7 7 8 9 9 10 11 11 12 13 13 14 15 15 16 17 17 18 19 19 20 21 21 22 23 23 24 25 25 26 27 27 28 29 29 30
每当收到2个数据后，这2个数据是一组，但由于是将缓存的3个数据存进List，就将下一组数据补充进来，导致重叠
1.1.3 buffer(func0)
原始的Observable产生数据后，当buffer(func0)订阅了后，将收到的数据存进List中，Func0会返回一个Observable对象具有监视作用，适当条件下这个Observable发出一个通知时(感觉随意发出一个数据就可以)，buffer就会将当前存放缓存数据的List发出去
private static void bufferFunc() {
Observable
//在当前线程，每隔100毫秒产生一个整数
.interval(0,100,TimeUnit.MILLISECONDS,Schedulers.immediate())
//限制为30个
.limit(30)
//每隔500毫秒发一个整数，发出的数据，可以看作通知
.buffer(new Func0>() {
@Override
public Observable call() {
return Observable.interval(500, TimeUnit.MILLISECONDS, Schedulers.newThread());
}
})
//将List集合打印
.subscribe(System.out::println);
}
运行结果：
[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[10, 11, 12, 13, 14]
[15, 16, 17, 18, 19]
[20, 21, 22, 23, 24]
[25, 26, 27, 28, 29]
1.1.4 buffer(Observable,Func1)
buffer(bufferOpenings, bufferClosingSelector)
原始Obseravble开始发送数据之后，buffer会监视bufferOpenings这个Observable，每当bufferOpenings发送出一个数据后,会创建出一个新的List开始存放原始的Obseravble发出的数据，相当于Open标记。bufferOpenings发出的数据叫bufferClosingSelector的Func1会接收到，当bufferClosingSelector接收到这个信号后，根据需求做相应的处理。Func1会返回一个新的Observable，当buffer监测到这个新的Observable时，就会关闭List，然后将List发送出去
private static void bufferOpenClose() {
Observable
//在当前线程 每隔100毫秒 从0开始 发出整数序列
.interval(0, 100, TimeUnit.MILLISECONDS, Schedulers.immediate())
.limit(30)
//buffer(bufferOpenings, bufferClosingSelector)
//bufferOpenings，每隔500毫秒发出一个整数，打开信号
//bufferClosingSelector，接到bufferOpenings发来的通知，延迟200毫秒后发出第一个关闭信号，之后每隔500毫秒发出一个整数进行通知
.buffer(Observable.interval(500, TimeUnit.MILLISECONDS, Schedulers.newThread()), new Func1>() {
@Override
public Observable call(Long aLong) {
System.out.println(aLong);
//200毫秒后，发出一个整数0，作用关闭信号
return Observable.timer(200,TimeUnit.MILLISECONDS,Schedulers.newThread());
}
})
.subscribe(System.out::println);
}
运行结果：
0
[5, 6]
1
[10, 11]
2
[15, 16]
3
[20, 21]
4
[25, 26]
当bufferOpenings发出第一个打开信号之后200毫秒那一时刻，bufferClosing会接到一个关闭关闭信号，这200毫秒内的数据项就会被存进一个List集合内，紧接着List遍被原始的Observable发送出去。第一次buffer便完成
在bufferOpenings发出第一个信号500毫秒时，发出第二个打开信号，之后200毫秒那一时刻，bufferClosing会接到一个关闭关闭信号，如此循环，重复，直到数据项没有
估计也就只有我自己看得懂了
1.2 GroupBy分组
GroupBy将原始的Observable拆分成多个组，每个组可以有一个自己的key，同一个key的数据由一个Obsvervable来发送
GroupBy返回的是Observable的一个特殊子类GroupedObservable，实现了GroupedObservable接口的对象有一个额外的方法getKey，根据拿到的key可以做对应的操作
默认不在任何特定的调度器上执行
1.2.1 groupBy(Func1)
简单使用：
/**
*将产生的数据中为偶数的输出打印
*
*/
private static void groupByFunc1() {
Observable
.interval(0, 100, TimeUnit.MILLISECONDS, Schedulers.immediate())
.limit(10)
//根据奇偶类型 返回不同的key 偶数为 "1"
.groupBy(new Func1() {
@Override
public String call(Long aLong) {
return aLong % 2 == 0 ? "1" : "2";
}
})
//根据stringLongGroupedObservable的key类型 输出
.subscribe(new Action1>() {
@Override
public void call(GroupedObservable stringLongGroupedObservable) {
if (stringLongGroupedObservable.getKey().equals("1")) {
stringLongGroupedObservable.subscribe(new Action1() {
@Override
public void call(Long aLong) {
System.out.print(aLong +",");
}
});
}
}
});
}
运行结果：
0,2,4,6,8,
1.2.2 groupBy(Func1,Func1)
这个方法可以对原始数据进行修改
简单使用：
/**
* 修改产生的数据中结果大于4的值
*/
private static void groupByMap() {
Observable
.interval(0, 100, TimeUnit.MILLISECONDS, Schedulers.immediate())
.limit(10)
.groupBy(new Func1() {
@Override
public String call(Long aLong) {
return aLong % 2 == 0 ? "1" : "2";
}
}, new Func1() {
@Override
public String call(Long aLong) {
return aLong > 4 ? (aLong + " -- > 哈") : (aLong + "");
}
}
// , new Func1, Map>() {
// @Override
// public Map call(Action1 stringAction1) {
// return null;
// }
// }
)
.subscribe(new Action1>() {
@Override
public void call(GroupedObservable stringLongGroupedObservable) {
if (stringLongGroupedObservable.getKey().equals("1")) {
stringLongGroupedObservable.subscribe(new Action1() {
@Override
public void call(String s) {
System.out.print(s + ",");
}
});
}
}
});
}
运行结果：
0,2,4,6 -- > 哈,8 -- > 哈,
方法中注释掉的是3个参数的方法，不知道怎么用的，看源码中的注释也没看明白，先不管了
1.3 Window窗口
定期将来自原始Observable的数据分解为一个Observable窗口，发射这些窗口，而不是每次发射一项数据
Window和Buffer有些类似，Buffer发送的是存放原始数据的List包裹，而Window发送的是Observable，发送的每个Observable都包含原始的Observable的数据子集，最后会发送一个onCompleted通知
1.3.1 window(Func0)
- window(closingSelector)
window(Func0)会打开一个窗口，当监测到closingSelector返回了一个Obsvable对象后，就会关闭当前的窗口打开一个新的窗口，并将在当前窗口打开期间的收集数据的Observable发送出去
发射一系列不重叠的窗口，这些窗口的数据集合与原始Observable发射的数据是一一对应的。
简单使用：
private static void windowFunc0() {
Observable
.interval(0, 100, TimeUnit.MILLISECONDS, Schedulers.immediate())
.limit(10)
.window(new Func0>() {
@Override
public Observable call() {
return Observable.timer(500, TimeUnit.MILLISECONDS);
}
})
.subscribe(new Subscriber>() {
@Override
public void onCompleted() {
System.out.println(" onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println(e.getMessage());
}
@Override
public void onNext(Observable longObservable) {
longObservable.forEach(new Action1() {
@Override
public void call(Long aLong) {
System.out.print(aLong + " ,");
}
});
}
});
}
运行结果：
0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 , onCompleted
1.3,2 window(int)
- window(count)
window打开一个窗口后，每当接收到count个数据后，就会关闭当前的窗口，打开下一个窗口。如果从原始Observable收到了onError或onCompleted通知它也会关闭当前窗口。
简单使用：
private static void windowCount() {
Observable
.interval(0, 100, TimeUnit.MILLISECONDS, Schedulers.immediate())
.limit(10)
.window(3)
.subscribe(longObservable -> longObservable.forEach(System.out::print));
}
运行结果：
0123456789
在输出结果时，是3个数据一起打印的，012有一种一瞬间一起打出来，然后停顿一下，接着打印下面的一组
1.3.3 window(long,TimeUnit,Scheduler)
- window(timespan, unit[, scheduler])
window打开一个窗口后，每当到了期限timespan后，就会关闭当前窗后，打开一个新的。时间单位是设置的unit，scheduler指定调度器
简单使用：
private static void windowTimeSpan() {
Observable
.interval(0, 100, TimeUnit.MILLISECONDS, Schedulers.immediate())
.limit(10)
.window(300,TimeUnit.MILLISECONDS,Schedulers.newThread())
.subscribe(new Action1>() {
@Override
public void call(Observable longObservable) {
longObservable.forEach((along)-> System.out.print(along +" ,"));
}
});
}
运行结果还是0~9十个数字
1.4 Sacn扫描
连续地对数据序列的每一项应用一个函数，然后连续发射结果,默认不在任何特定的调度器上执行
- scan(Func2)
当原始数据发送第一个数据后，Scan操作符会将Func2中指定的函数应用到第一个数据上，并将操作结果作为Scan自身第一个数据发送出去。后续第二个数据作为Fun2.call()方法的第二个参数，而第一次函数操作的结果，作为第一个参数，再次待用函数。之后数据项都会重复，前一次的结果作为call()第一个参数，后一个数据项作为第2个参数，直到最后一个数据项，最后会发送onCompleted通知。Scan操作符在某些情况下被叫做accumulator
简单使用：
/**
* 前n项累加和
*/
private static void scanSum() {
Observable
.range(1,10)
.scan(new Func2() {
@Override
public Integer call(Integer sum, Integer item) {
return sum + item;
}
})
.subscribe((n) -> System.out.print(n + " ,"));
}
运行结果：
1 ,3 ,6 ,10 ,15 ,21 ,28 ,36 ,45 ,55 ,
2. 最后
Map,FlatMap之前已经学习了解过了，这里不想再次重复
这两天《你的名字》上映了，听说很不错，约不到妹纸，一会就在电脑看了，哈哈
本人很菜，有错误请指出
共勉 ：）