RxJava异步
*RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，概括得非常精准。
*
RxJava好处
简洁异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。 Android 创造的 AsyncTask 和Handler ，其实都是为了让异步代码更加简洁。RxJava 的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
- 概念：扩展的观察者模式
- RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。
- RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。
- onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 one rror() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 one rror() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
public class Rxjava {
public static void main(String[] args) {
/* new Observable<String>(){
@Override
protected void subscribeActual(Observer<? super String> observer) {
observer.onNext("玻璃瓶");
observer.onNext("啤酒瓶");
observer.onComplete();
}
}.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
System.out.println("接收到了：" + s);
}
@Override
public void one rror(Throwable e) {
}
@Override
public void onComplete() {
System.out.println("接收数据完毕");
}
});*/
// mapOpretor();
// flatMapOpretor();
// groupByOperator();
// filterOperator();
// distinctOperator();
// ignoreElements();
// elementAtOperator();
windowOperator();
}
//map操作符
public static void mapOpretor(){
Observable.just("HELLO")
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return s.toLowerCase();
}
})
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return s + ",world";
}
})
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
System.out.println("接收到的数据是:" + s);
}
@Override
public void one rror(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
//flatMap操作符
public static void flatMapOpretor() {
User user = new User();
user.userName = "zhangsan";
user.addresss = new ArrayList<>();
User.Address address1 = new User.Address();
// User.Address address1 = new User.Address();
address1.street = "上地九街";
address1.city = "北京";
user.addresss.add(address1);
User.Address address2 = new User.Address();
address2.street = "上地十街";
address2.city = "上海";
user.addresss.add(address2);
/*Observable.just(user)
.map(new Function<User, List<User.Address>>() {
@Override
public List<User.Address> apply(User user) throws Exception {
return user.addresss;
}
}).subscribe(new Consumer<List<User.Address>>() {
@Override
public void accept(List<User.Address> addresses) throws Exception {
for (int i = 0; i < addresses.size(); i++) {
System.out.println("地址是：" + addresses.get(i).street);
}
}
});*/
Observable.just(user)
.flatMap(new Function<User, ObservableSource<User.Address>>() {
@Override
public ObservableSource<User.Address> apply(User user) throws Exception {
return Observable.fromIterable(user.addresss);
}
})
.subscribe(new Consumer<User.Address>() {
@Override
public void accept(User.Address address) throws Exception {
System.out.println("地址是：" + address.street);
}
});
}
//groupBy操作符
public static void groupByOperator(){
Observable
.range(1,8)
.groupBy(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return (integer % 2 == 0)? "偶数组":"奇数组";
}
}).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
@Override
public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {
if(stringIntegerGroupedObservable.getKey().equals("奇数组")){
stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println(stringIntegerGroupedObservable.getKey() + "member:" + integer);
}
});
}/*else if(stringIntegerGroupedObservable.getKey().equals("偶偶组")){
stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println(stringIntegerGroupedObservable.getKey() + "member:" + integer);
}
});
}*/
System.out.println();
}
});
}
//filter操作符
public static void filterOperator(){
Observable.just(1,8,20,3,50,4,6,100)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer > 8;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("next :" + integer);
}
});
}
//distinct过滤掉重复的数据项
public static void distinctOperator() {
Observable.just("A","A","B")
.distinct()
.subscribe(new Consumer<String>() {
@Override
public void accept(String integer) throws Exception {
System.out.println("next :" + integer);
}
});
}
//ignoreElements 不发射任何数据
public static void ignoreElements() {
Observable.just(1,2,3,4,5)
.ignoreElements()
.subscribe(new Action() {
@Override
public void run() throws Exception {
System.out.println("完成了任务");
}
});
}
//elementAt 只发射第n项数据
public static void elementAtOperator() {
Observable.just(1,2,3,4,5,6,7)
.elementAt(2)
// .elementAt(12,34)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("next:" + integer);
}
});
}
//window操作符
public static void windowOperator() {
Observable.range(1,10)
.window(2)
.subscribe(new Consumer<Observable<Integer>>() {
@Override
public void accept(Observable<Integer> integerObservable) throws Exception {
System.out.println("On next:" );
integerObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("accept:" + integer );
}
});
}
});
}
}