布尔操作符
我们可以使用布尔操作符,对源数据Observable发送的数据进行变换或者是直接的布尔操作,来达到一些目的。
all 操作符
Observable<Boolean> all(Func1<? super T, Boolean> predicate)
用于判断Observable的所有数据是否满足某一个条件
例如:
Observable.range(10,3).all(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer>9;
}
}).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.i(TAG, "all" + aBoolean.toString());
}
});
输出是true,加入把条件改为
@Override
public Boolean call(Integer integer) {
return integer>11;
}
那么就是输出false了。
图:
amb 操作符
Observable<T> amb(Iterable<? extends Observable<? extends T>> sources)
Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2)
Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3)
...... 还有其他的,同样是上面哪样子的
amb操作符的作用是用于比较两个Observable,然后哪一个先发射数据就只是发射这个Observable的数据,抛弃其他的Observable数据,不论他第一个是发射了onError还是onComplete,例子:
Observable<Integer> o1 = Observable.range(20, 1).delay(200, TimeUnit.MILLISECONDS);
Observable<Integer> o2 = Observable.range(10, 1).delay(100, TimeUnit.MILLISECONDS);
Observable.amb(o1, o2).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, "amb==" + integer.toString());
}
});
输出:
amb==10
有一个ambWith操作符:
Observable<T> ambWith(Observable<? extends T> t1)
他是一个非静态的,作用跟上面的一样。
图:
contains 操作符
Observable<Boolean> contains(final Object element)
该操作符的作用是用于判断源数据时候包含某一个元素,例如:
Observable.range(10,5).contains(11).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.i(TAG,aBoolean.toString());
}
});
输出是true,因为源数据的范围是10-14之间,包含11.
图:
defaultIfEmpty 操作符
Observable<T> defaultIfEmpty(final T defaultValue)
该操作符的作用是在源Observable没有发射数据的时候发射一个默认数据,但是有onComplete()调用,表明他已经发射数据完毕,在没有数据发射的时候调用了onError是不会发射默认数据的,例如:
Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onCompleted();
// subscriber.onError(new IllegalArgumentException("error"));
}
});
ob.defaultIfEmpty("A").subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, s);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Log.i(TAG, throwable.getMessage());
}
});
结果是:A,假如是发射onError的时候则是只输出“error”,而不会输出A
图:
sequenceEqual 操作符
Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second)
Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality)
第一个函数,用于判断输入的两个Observable是否相同,包括发射长度,顺序,值,终止状态,例如:
Observable.sequenceEqual(Observable.just("A","B"),Observable.just("A","B")).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.i(TAG, aBoolean.toString());
}
});
输出就是true,把第二个Observable改为Observable.just(“B”,”A”),输出就是false。
终止状态不同的时候,比如:
Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("A");
subscriber.onCompleted();
}
});
Observable<String> o2 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("A");
subscriber.onError(new IllegalArgumentException("Error"));
}
});
Observable.sequenceEqual(o1,o2).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.i(TAG, aBoolean.toString());
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Log.i(TAG, throwable.getMessage());
}
});
就会输出了error。
第二个函数,他多了一个参数,是用于比较,自己确定规则的那种比较,两个Observable的值是否相同。例如:
Observable.sequenceEqual(Observable.just("A"), Observable.just("A"), new Func2<String, String, Boolean>() {
@Override
public Boolean call(String s, String s2) {
return s.equals(s2);
}
}).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.i(TAG, aBoolean.toString());
}
});
就是输出true,
图:
skipUntil 操作符
Observable<T> skipUntil(Observable<U> other)
用于废弃源Observable,知道other操作符符发射数据,例如:
Observable<String> s1 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("C");
subscriber.onNext("E");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
subscriber.onNext("D");
}
});
s1.subscribeOn(Schedulers.newThread())
.skipUntil(Observable.just("B")
.delay(100, TimeUnit.MILLISECONDS))
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, s);
}
});
输出结果是只输出了D,以为前面的C,E在other发射数据之前已经发射,所以会被丢弃。
图:
skipWhile 操作符
Observable<T> skipWhile(Func1<? super T, Boolean> predicate)
他的作用在于可以自己定规则,忽略前面不符合条件的数据,但是当一旦返回了true,该数据就不会被发射,然后predicate谓词还是会被调用,但是当predicate返回了false之后就不会再次被调用。例如:
Observable<String> s1 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("C");
subscriber.onNext("E");
subscriber.onNext("D");
subscriber.onNext("F");
subscriber.onCompleted();
}
});
s1.skipWhile(new Func1<String, Boolean>() {
@Override
public Boolean call(String s) {
Log.i(TAG, "skipWhile");
return s.equals("C");
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, s);
}
});
输出:
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: skipWhile
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: skipWhile
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: E
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: D
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: F
可以看到C没有输出,而且调用了skipWhile两次,skipWhile返回了false之后就没有被再次调用而是直接发射了源Observable后面的数据。
图:
TakeUntil 操作符
Observable<T> takeUntil(Observable<? extends E> other)
他的作用在于other在发射一个数据或者是onComplete的时候,回去终止源Observable发射数据,例如:
Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("A");
subscriber.onNext("B");
subscriber.onNext("C");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
subscriber.onNext("D");
}
});
o1.subscribeOn(Schedulers.newThread())
.takeUntil(Observable.empty().delay(100, TimeUnit.MILLISECONDS))
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, s);
}
});
输出结果:
11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: A
11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: B
11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: C
可以看到other是在100ms之后再去发射数据的,observable在100ms之后发射的数据会被忽略。图:
.### TakeWhile 操作符
Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
他的作用是通过predicate函数返回一个boolean值,假如是返回了true,则发射该数据,但是一旦返回来false,就终止源Observable的发射,同时调用他的onComplete()方法,例子:
Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("A");
subscriber.onNext("B");
subscriber.onNext("C");
subscriber.onNext("D");
subscriber.onCompleted();
}
});
o1.takeWhile(new Func1<String, Boolean>() {
@Override
public Boolean call(String s) {
Log.i(TAG, "takeWhile=="+s);
return s.equals("C");
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, s);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
}
}, new Action0() {
@Override
public void call() {
Log.i(TAG, "OnComplete");
}
});
输出结果:
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==A
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: OnComplete
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==B
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==C
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==D
因为第一个数据就使得predicate返回了false,所以终止了发射,假如predicate换成:
@Override
public Boolean call(String s) {
Log.i(TAG, "takeWhile==" + s);
return !s.equals("E");
}
则会输出全部,图: