Rxjava 在项目中的简单使用

来源：互联网发布：js 数组合计编辑：程序博客网时间：2024/05/18 02:26

防止重复点击

 RxView.clicks(mBinding.btclick).throttleFirst(2, TimeUnit.SECONDS)                .subscribe(new Consumer<Object>() {                    @Override                    public void accept(Object o) throws Exception {                        ToastUtils.showToast(TestActivity.this, "2秒内只能点击一次");                    }                });

监听输入框内容状态变化

  RxTextView.textChanges(mBinding.etTest).skip(5).subscribe(new Consumer<CharSequence>() {            @Override            public void accept(CharSequence charSequence) throws Exception {                if(!TextUtils.isEmpty(charSequence.toString())){                    ToastUtils.showToast(TestActivity.this,"输入框不为空");                }else{                    ToastUtils.showToast(TestActivity.this,"输入框为空");                }            }        });

这里的skip（long count）里面的参数的意思是当输入框内容第一次到达count数量时候，开始进行输入状态监听。

如果有需要监听多个EditText的内容变化时候，可以这么写：

 Observable<CharSequence> ob1 = RxTextView.textChanges(mBinding.etTest1).skip(1);        Observable<CharSequence> ob2 = RxTextView.textChanges(mBinding.etTest2).skip(1);        Observable.combineLatest(ob1, ob2, new BiFunction<CharSequence, CharSequence, Boolean>() {            @Override            public Boolean apply(CharSequence charSequence, CharSequence charSequence2) throws Exception {                return charSequence.length()>5 && charSequence2.length()>10;            }        }).subscribe(new Consumer<Boolean>() {            @Override            public void accept(Boolean aBoolean) throws Exception {                if(aBoolean) {                    Log.d("数量", "符合要求");                }            }        });

延迟任务

mBinding.btclick.setOnClickListener( v->{            Observable.timer(3, TimeUnit.SECONDS).subscribeOn(Schedulers.io())                    .observeOn(AndroidSchedulers.mainThread())            .subscribe(new Consumer<Long>() {                @Override                public void accept(Long aLong) throws Exception {                    ToastUtils.showToast(TestActivity.this,"3秒延迟执行");                }            });        });

异步填充集合

     private List<String> mList;     private Disposable disposable;disposable = Observable.create(new ObservableOnSubscribe<TaskItem>() {            @Override            public void subscribe(ObservableEmitter<TaskItem> e) throws Exception {                for (int i = 0; i < 10; i++) {                    TaskItem item = new TaskItem("123456789"+i,123456789,987654321, new Random().nextBoolean());                    e.onNext(item);                }            }        }).subscribeOn(Schedulers.newThread())           .observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<TaskItem>() {            @Override            public void accept(TaskItem taskItem) throws Exception {                mList.add(taskItem);            }        });

基本写法

Observable.create(new ObservableOnSubscribe<Integer>() {                @Override                public void subscribe(ObservableEmitter<Integer> e) throws Exception {                    for (int i = 0; i < 10; i++){                        e.onNext(i);                    }                    e.onComplete();                }            }).subscribe(new Observer<Integer>() {                @Override                public void onSubscribe(Disposable d) {                    Log.d("测试数量","disPosablle");                }                @Override                public void onNext(Integer integer) {                    Log.d("测试数量",integer.toString());                }                @Override                public void onError(Throwable e) {                    Log.d("测试数量",e.toString());                }                @Override                public void onComplete() {                    Log.d("测试数量","onComplete");                }            });

基本类型转换（map）

/**     * map         * 基本类型转换 一对一         *  just(T...)将传入的参数依次发送         *  from(T[])/from(Iterable<? extends T>)将传入的数组或者Iterable拆分成Java对象依次发送         */ Observable.just(1, 2, 3, 4, 5)                    .map(new Function<Integer, String>() {                        @Override                        public String apply(Integer integer) throws Exception {                            return "This is" + integer;                        }                    }).subscribe(new Consumer<String>() {                @Override                public void accept(String s) throws Exception {                    System.out.println(s);                }            });

遍历集合取数据

 Observable.fromIterable(list).flatMap(new Function<TaskItem, ObservableSource<? extends String>>() {            @Override            public ObservableSource<? extends String> apply(TaskItem taskItem) throws Exception {                return Observable.just(taskItem.getTaskNum());            }        }).subscribe(new Consumer<String>() {            @Override            public void accept(String s) throws Exception {                System.out.println(s);            }        });

过滤分组

   {            Observable.fromIterable(list).groupBy(new Function<TaskItem, Boolean>() {                @Override                public Boolean apply(TaskItem taskItem) throws Exception {                    return taskItem.isChecked();                }            }).subscribe(new Consumer<GroupedObservable<Boolean, TaskItem>>() {                @Override                public void accept(GroupedObservable<Boolean, TaskItem> booleanTaskItemGroupedObservable) throws Exception {                    if (booleanTaskItemGroupedObservable.getKey()){                        booleanTaskItemGroupedObservable.subscribe(new Consumer<TaskItem>() {                            @Override                            public void accept(TaskItem taskItem) throws Exception {                                System.out.print("boolean值" + booleanTaskItemGroupedObservable.getKey()+": ");                                System.out.println(taskItem);                            }                        });                    }else{                        booleanTaskItemGroupedObservable.subscribe(new Consumer<TaskItem>() {                            @Override                            public void accept(TaskItem taskItem) throws Exception {                                System.out.print("boolean值" + booleanTaskItemGroupedObservable.getKey()+": ");                                System.out.println(taskItem);                            }                        });                    }            }            });        }

在consumer端再次订阅的时候，相当于直接在上一次订阅的基础上继续订阅，在此之前中的方法不会执行，错误示例如下：

{            Observable.fromIterable(list).groupBy(new Function<TaskItem, Boolean>() {                @Override                public Boolean apply(TaskItem taskItem) throws Exception {                    return taskItem.isChecked();                }            }).subscribe(new Consumer<GroupedObservable<Boolean, TaskItem>>() {                @Override                public void accept(GroupedObservable<Boolean, TaskItem> booleanTaskItemGroupedObservable) throws Exception {                    if (booleanTaskItemGroupedObservable.getKey()) {                        booleanTaskItemGroupedObservable.subscribe(new Consumer<TaskItem>() {                        //这里打印只会执行一次 以后不会再次打印                          System.out.print("boolean值" + booleanTaskItemGroupedObservable.getKey() + ": ");                            @Override                            public void accept(TaskItem taskItem) throws Exception {                                                            System.out.println(taskItem);                            }                        });                    } else {                        booleanTaskItemGroupedObservable.subscribe(new Consumer<TaskItem>() {                         System.out.print("boolean值" + booleanTaskItemGroupedObservable.getKey() + ": ");                            @Override                            public void accept(TaskItem taskItem) throws Exception {                                                               System.out.println(taskItem);                            }                        });                    }                }            });        }

点击事件

 RxView.clicks(mBinding.btclick).subscribe(new Consumer<Object>() {            @Override            public void accept(Object s) throws Exception {                ToastUtils.showToast(TestActivity.this,"这是点击事件");            }        });

这里注意，Consumer里的方法不能随便更改，会报找不到方法的错误，后期我正常使用的时候，有新发现我会再补充。

过滤器（filter）

 RxView.clicks(mBinding.btclick).subscribe(v ->        {            Observable.fromIterable(list).filter(new Predicate<TaskItem>() {                @Override                public boolean test(TaskItem taskItem) throws Exception {                    return taskItem.isChecked();                }            }).subscribe(new Consumer<TaskItem>() {                @Override                public void accept(TaskItem consumer) throws Exception {                    System.out.println(consumer.getTaskNum());                }            });        });

filter里的匿名内部类的实现返回的是一个boolean值，这里作为判断依据筛选出需要被发送的数据。

发送前n个元素（take）

 RxView.clicks(mBinding.btclick).subscribe(v->{            Observable.fromIterable(list).take(5).filter(new Predicate<TaskItem>() {                @Override                public boolean test(TaskItem taskItem) throws Exception {                    return taskItem.isChecked();                }            }).subscribe(new Consumer<TaskItem>() {                @Override                public void accept(TaskItem con) throws Exception {                    System.out.println(con.getTaskNum());                }            });        });

分组（groupBy）

上一个示例是有点小问题的，但是也可以使用，排序上达不到要求，这里补充一下

RxView.clicks(mBinding.btclick).subscribe(v->{            Observable<GroupedObservable<String,TestItem>> observable = Observable.fromIterable(testList).groupBy(new Function<TestItem, String>() {                @Override                public String apply(TestItem testItem) throws Exception {                    return testItem.getPlace();                }            });            Observable.concat(observable).subscribe(new Consumer<TestItem>() {                @Override                public void accept(TestItem testItem) throws Exception {                    System.out.println("小区:"+testItem.getName()+"; 房源描述:"+testItem.getPlace()+"房屋价格"+testItem.getPrice());                }            });        });

需要有分组的依据，类似于冒泡排序，找到一个就以当前下标对应的数值作为初始分组，往后找寻与它在同一分组的数值下标，并把对应的下标和数值移到当前下标的下一个位置。

组合（merge）

 String[] letters = new String[]{"A","B","C","D","E","F","G","H"};        RxView.clicks(mBinding.btclick).subscribe( v->{            Observable<String> letter = Observable.interval(300, TimeUnit.MILLISECONDS)                    .map(new Function<Long, String>() {                        @Override                        public String apply(Long aLong) throws Exception {                            return letters[aLong.intValue()];                        }                    }).take(letters.length);            Observable<Long> number = Observable.interval(500,TimeUnit.MILLISECONDS)                    .take(5);            Observable.merge(letter,number).subscribe(new Consumer<Serializable>() {                @Override                public void accept(Serializable serializable) throws Exception {                    System.out.println(serializable);                }            });        });

这里组合的意思，是按照发送元素的时间先后依次组合的。

插入数据（startWitch）

这里只能在源Observable发送数据前插入数据

插入数据（concat）

这里与startWitch的不同在于concat严格按照Observable的先后次序插入数据

  String[] letters = new String[]{"A","B","C","D","E","F","G","H"};        RxView.clicks(mBinding.btclick).subscribe( v->{            Observable<String> letter = Observable.interval(300, TimeUnit.MILLISECONDS)                    .map(new Function<Long, String>() {                        @Override                        public String apply(Long aLong) throws Exception {                            return letters[aLong.intValue()];                        }                    }).take(letters.length);            Observable<Long> number = Observable.interval(500,TimeUnit.MILLISECONDS)                    .take(5);            Observable.concat(letter,number).subscribe(new Consumer<Serializable>() {                @Override                public void accept(Serializable serializable) throws Exception {                    System.out.println(serializable);                }            });        });

这里会等到前一个（letter）数据发送完成后才会发送后面（number）的数据

组合发射（zip）

/*** 这里接着上面的，Observable还是用上面的*/ Observable.zip(letter, number, new BiFunction<String, Long, String>() {                @Override                public String apply(String s, Long aLong) throws Exception {                    return s +aLong;                }            }).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() {                }            });

需要注意的是，zip组合的时候，当其中的某一个Observable发送元素出现异常时，另一个也会停止发送。

combineLatest

combineLatest(Observable, Observable, Func2)用于将两个Observale最近发射的数据已经Func2函数的规则进展组合。

 List<String> strings1 = new ArrayList<String>() {{            add("你好");add("很好"); add("非常好");        }};        List<String> strings2 = new ArrayList<String>() {{            add("你hen好");add("很hen好"); add("hen非常好");        }};        RxView.clicks(mBinding.btclick).subscribe(v -> {            Observable<String> s1 = Observable.interval(1,TimeUnit.SECONDS)                    .map(new Function<Long, String>() {                        @Override                        public String apply(Long aLong) throws Exception {                            return strings1.get(aLong.intValue());                        }                    }).take(strings1.size());            Observable<String> s2 = Observable.interval(1,TimeUnit.SECONDS)                    .map(new Function<Long, String>() {                        @Override                        public String apply(Long aLong) throws Exception {                            return strings2.get(aLong.intValue());                        }                    }).take(strings2.size());            //这里take表示发送的元素个数  去掉会报错关闭页面            Observable.combineLatest(s1, s2, new BiFunction<String, String, String>() {                @Override                public String apply(String s, String s2) throws Exception {                    return "name"+ s + "page" +s2;                }            }).subscribe(new Consumer<String>() {                @Override                public void accept(String s) throws Exception {                    System.out.println(s);                }            });        });

阅读全文

0 0