map，flatMap，groupBy，filter操作符，distinct过滤掉重复的数据项，ignoreElements 不发射任何数据，elementAt 只发射第n项数据，window操作符

public class Rxjava {
public static void main(String[] args) {

  }
//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 onError(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 );

                        }
                    });

                }
            });
}


}

//User类
public class User {

    public String userName;
    public List<Address> addresss;


    public static class Address{
        public String street;
        public String city;
    }
}