一、using
创建一个只在Observable生命周期存在的资源
//一个用户创建一次性资源的工厂函数
Func0<Integer> resourceFactory = new Func0<Integer>() {
@Override
public Integer call() {
return 1;
}
};
//一个用于创建Observable的工厂函数
Func1<Integer, Observable<String>> observableFactory = new Func1<Integer, Observable<String>>() {
@Override
public Observable<String> call(Integer integer) {
return Observable.just(integer+"。。。。。。创建observable的工厂函数");
}
};
//一个用于释放资源的函数
Action1<Integer> disposeAction = new Action1<Integer>(){
@Override
public void call(Integer integer) {
Log.e(TAG,"释放资源的函数。。。。。。。。。"+integer);
}
};
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onNext(String v) {
Log.e(TAG,"onNext................."+v);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
Observable.using(resourceFactory,observableFactory,disposeAction).subscribe(subscriber);
二、first
只发射第一项（或者满足某个条件的第一项）数据。如果你只对Observable发射的第一项数据，或者满足某个条件的第一项数据感兴趣，你可以使用First操作符。在某些实现中，First没有实现为一个返回Observable的过滤操作符，而是实现为一个在当时就发射原始Observable指定数据项的阻塞函数。在这些实现中，如果你想要的是一个过滤操作符，最好使用Take(1)者ElementAt(0)。
在一些实现中还有一个Single操作符。它的行为与First类似，但为了确保只发射单个值，它会等待原始Observable终止（否则，不是发射那个值，而是以一个错误通知终止）。你可以使用它从原始Observable获取第一项数据，而且也确保只发射一项数据。
在RxJava中，这个操作符被实现为first，firstOrDefault和takeFirst。可能容易混淆，BlockingObservable也有名叫first和firstOrDefault的操作符，它们会阻塞并返回值，不是立即返回一个Observable。
三、firstOrDefault
firstOrDefault与first类似，但是在Observagle没有发射任何数据时发射一个你在参数中指定的默认值。
四、single
single操作符也与first类似，但是如果原始Observable在完成之前不是正好发射一次数据，它会抛出一个NoSuchElementException。
五、singleOrDefualt
和firstOrDefault(T, Func1)类似，如果没有数据满足条件，返回默认值；如果有多个数据满足条件，以错误通知终止。
六、getIterator
getIterator操作符只能用于BlockingObservable的子类，要使用它，你首先必须把原始的Observable转换为一个BlockingObservable。可以使用这两个操作符：BlockingObservable.from或the Observable.toBlocking。将observable转成数据结果iterator类型，然后可以按iterator来获取数据。是阻塞式的，当有observable发出时才会输出数据。
每隔1s打印一个数据
BlockingObservable<Long> blockingObservable = BlockingObservable.from(Observable.interval(1,TimeUnit.SECONDS).take(5));
Iterator<Long> iterator = blockingObservable.getIterator();
while (iterator.hasNext()){
Log.e(TAG,"发出的数据是..............." + iterator.next());
}运行结果：
七、toFuture
toFuture操作符也是只能用于BlockingObservable。这个操作符将Observable转换为一个返回单个数据项的Future，如果原始Observable发射多个数据项，Future会收到一个IllegalArgumentException；如果原始Observable没有发射任何数据，Future会收到一个NoSuchElementException。如果你想将发射多个数据项的Observable转换为Future，可以这样用：myObservable.toList().toBlocking().toFuture()。
发射了多个数据，产生了异常
1.
BlockingObservable<Long> blockingObservable = BlockingObservable.from(Observable.interval(1,TimeUnit.SECONDS).take(5));
Future<Long> future = blockingObservable.toFuture();
long l = -1;
try {
l = future.get();
}catch (Exception e){
}
Log.e(TAG,"应该获取到的数据是....................."+l);
运行结果：
2.发送Observable集合，这个过程是阻塞的，当5s后才输出数据结果
Future<List<Long>> futureList = Observable.interval(1, TimeUnit.SECONDS).take(5).toList().toBlocking().toFuture();
List<Long> list= null;
try {
list = futureList.get();
for(long l : list){
Log.e(TAG,"取到的数据是....................."+l);
}
} catch (Exception e) {
e.printStackTrace();
}
八、toIterator
将observable转成数据类型iterable，阻塞式。toFuture操作符也是只能用于BlockingObservable。这个操作符将Observable转换为一个Iterable，你可以通过它迭代原始Observable发射的数据集。
Iterable<List<Long>> iterableList = Observable.interval(1, TimeUnit.SECONDS).take(5).toList().toBlocking().toIterable();
Iterator<List<Long>> iteratorLists = null;
List<Long> list = null;
try {
iteratorLists = iterableList.iterator();
while (iteratorLists.hasNext()) {
list = iteratorLists.next();
}
for(long l : list){
Log.e(TAG,"取到的数据是....................."+l);
}
} catch (Exception e) {
e.printStackTrace();
}九、toList
将Observable转成数据类型list，阻塞式。通常，发射多项数据的Observable会为每一项数据调用onNext方法。你可以用toList操作符改变这个行为，让Observable将多项数据组合成一个List，然后调用一次onNext方法传递整个列表。
如果原始Observable没有发射任何数据就调用了onCompleted，toList返回的Observable会在调用onCompleted之前发射一个空列表。如果原始Observable调用了onError，toList返回的Observable会立即调用它的观察者的onError方法。
十、toMap
将Observable转成数据类型map，阻塞式。toMap收集原始Observable发射的所有数据项到一个Map（默认是HashMap）然后发射这个Map。你可以提供一个用于生成Map的Key的函数，还可以提供一个函数转换数据项到Map存储的值（默认数据项本身就是值）。
Observable<Map<String, Long>> observable = Observable.interval(1, TimeUnit.SECONDS).take(5).toMap(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return aLong + "";
}
});
Subscriber<Map<String, Long>> subscriber = new Subscriber<Map<String, Long>>() {
@Override
public void onNext(Map<String, Long> map) {
Set<Map.Entry<String, Long>> set = map.entrySet();
for(Map.Entry entry:set) {
Log.e(TAG, "onNext.................key:" + entry.getKey()+"...............value:"+entry.getValue());
}
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
observable.subscribe(subscriber);运行结果：
十一、toMultiMap
toMultiMap类似于toMap，不同的是，它生成的这个Map同时还是一个ArrayList（默认是这样，你可以传递一个可选的工厂方法修改这个行为）。toMultiMap默认不在任何特定的调度器上执行。
Observable<Map<String, Collection<Long>>> observable = Observable.interval(1, TimeUnit.SECONDS).take(5).toMultimap(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return "testMultiMap" + aLong;
}
});
Subscriber<Map<String, Collection<Long>>> subscriber = new Subscriber<Map<String, Collection<Long>>>() {
@Override
public void onNext(Map<String, Collection<Long>>map) {
Set<Map.Entry<String, Collection<Long>>> set = map.entrySet();
for(Map.Entry entry:set) {
Log.e(TAG, "onNext.................key:" + entry.getKey()+"...............value:"+entry.getValue());
}
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
observable.subscribe(subscriber);
十二、toSortedList
oSortedList类似于toList，不同的是，它会对产生的列表排序，默认是自然升序，如果发射的数据项没有实现Comparable接口，会抛出一个异常。然而，你也可以传递一个函数作为用于比较两个数据项，这是toSortedList不会使用Comparable接口。
十三、nest
nest操作符有一个特殊的用途：将一个Observable转换为一个发射这个Observable的Observable。
Observable<String> observable = Observable.just("nest1","nest2","nest3","nest4","nest5");
final Subscriber<String> subscriber1 = new Subscriber<String>() {
@Override
public void onNext(String v) {
Log.e(TAG, "onNext<String>................." + v);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
Subscriber<Observable<String>> subscriber = new Subscriber<Observable<String>>() {
@Override
public void onNext(Observable<String> v) {
Log.e(TAG, "onNextObservable<String>................." + v.subscribe(subscriber1));
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
Observable<Observable<String>> observable1 = observable.nest();
observable1.subscribe(subscriber);运行结果：
扫一扫
134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
