RxJava学习笔记（过滤Observables）

Filter

RxJava让我们使用filter()方法来过滤观测序列中我们不想要的值。

• 先来个没有带过滤的

    public static void main(String... args) {
        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("张三");
                subscriber.onNext("李四");
                subscriber.onNext("王五");
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
  
            }
  
            @Override
            public void onError(Throwable e) {
  
            }
  
            @Override
            public void onNext(String s) {
                System.out.println("我是" + s);
            }
        });
    }
  

打印结果：

我是张三

我是李四

我是王五

• 现在在创建Observable之后添加filter()方法。

    public static void main(String... args) {
        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("张三");
                subscriber.onNext("李四");
                subscriber.onNext("王五");
            }
        }).filter(new Func1() {
            @Override
            public Boolean call(String s) {
                return s.startsWith("李");
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
  
            }
  
            @Override
            public void onError(Throwable e) {
  
            }
  
            @Override
            public void onNext(String s) {
                System.out.println("我是" + s);
            }
        });
    }
  

• 可以看到添加的filter()方法，判断字符串是否以"李"开头，返回一个布尔值，只要条件符合filter()函数就会返回true。此时，该值就会发送出去。

• 打印结果：
  
  我是李四
  

Take

许多时候，可能生产者（也就是被观察者）订阅了好几个消费者（也就是观察者），以后就用生产者和消费者来叙述，观察者和被观察者拗口得要命有木有！言归正传，生产者会产生一条数据流，而你消费者可能仅仅只需要开头或者结尾的几个元素，那么RxJava也为我们提供了take()和takeLast()方法来实现。

• take()，如果我们只想要一个观测序列中的前两个元素，给take()传入参数：整数2，就能实现。

    public static void main(String... args) {
        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("张三");
                subscriber.onNext("李四");
                subscriber.onNext("王五");
            }
        })
                .take(2)
                .subscribe(new Observer() {
                    @Override
                    public void onCompleted() {
  
                    }
  
                    @Override
                    public void onError(Throwable e) {
  
                    }
  
                    @Override
                    public void onNext(String s) {
                        System.out.println("我是" + s);
                    }
                });
    }
  

打印结果：

我是张三

我是李四

在这里的take(n),表示的是说生产者发送前n个数据，n = 2 也就发送前两个数据，并不是说数据全部发完，截取前两个数据。

• takeLast()能够让我们发送后几个数据元素。

    public static void main(String... args) {
        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("张三");
                subscriber.onNext("李四");
                subscriber.onNext("王五");
                subscriber.onCompleted();
            }
        })
                .takeLast(1)
                .subscribe(new Observer() {
                    @Override
                    public void onCompleted() {
    
                    }
    
                    @Override
                    public void onError(Throwable e) {
    
                    }
    
                    @Override
                    public void onNext(String s) {
                        System.out.println("我是" + s);
                    }
                });
    }
  

同样的，不能少了subscriber.onCompleted()。
打印结果：

我是王五

Distinct

distinct()作用于一个完整的序列，所有重复的数据项只会发射一次。

public static void main(String... args) {
    Observable.just(1,2,1,2)
            .distinct()
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

i = 1

i = 2

DistinctUntilChanged

distinctUntilChanged()与distinct()相类似，不过distinctUntilChanged()是判断当前发射的值与前一个数据是否相同，在实际中，可以假设情形比如说UI根据获取到的数据不同更新自身UI，但是如果数据内容并没有发生改变，出于不浪费资源的目的，就不要发射数据。

public static void main(String... args) {
    Observable.just(1,2,2)
            .distinct()
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

i = 1

i = 2

First

first()从Observable中只发射第一个元素，或者添加参数first(Fun1)只发送符合条件的第一个数据项。

public static void main(String... args) {
    Observable.just(1,2,2)
            .first()
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

i = 1

public static void main(String... args) {
    Observable.just(1,2,2)
            .first(new Func1() {
                @Override
                public Boolean call(Integer integer) {
                    return integer == 2;
                }
            })
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

i = 2

Last

first()从Observable中只发射最后一个元素，或者添加参数first(Fun1)只发送符合条件的最后一个数据项。代码参考First。

Skip

skip(int)可以让我们忽略Observable前n个元素，而直接跳过这n个元素发射后面的元素。

public static void main(String... args) {
    Observable.just(1,2,2)
            .skip(2)
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

i = 2

SkipLast

skipLast(int)则是忽略后n个元素的发射。

ElementAt

现在我们有了控制前后的元素过滤规则，那么自然会有一个问题，如果我只想要观测序列其中的一个元素该怎么办呢，那么elementAt(int)就能实现。elementAt(int)用来获取元素Observable发射的事件序列中的第n项数据，并当做唯一的数据发射出去。

public static void main(String... args) {
    Observable.just(1,2,3)
            .elementAt(2)
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

i = 3

同时还有一个拓展方法，如果想查找第六个元素，但是可观测序列只有三个元素怎么办，可以用elementAtOrDefault(int index, T defaultValue)，在第二个参数传入一个默认值。

Sample

假如我们有一个温度传感器，每秒钟都会发射一次室内温度，然后UI根据温度变化而更新，但是有一个问题，我们认为每秒钟就获取一次数据并更新相当的浪费资源，再说温度也不一定变化这么快，那么我们就需要一个小小的发射间隔。sample()就能帮我们做到这一点，在Observable后面加一个sample(),将创建一个新的观测序列，并且它会在指定的时间间隔里由Observable发射最近的一次数值。

public static void main(String... args) {
    Observable observable = Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(Subscriber subscriber) {
            for (int i = 0; i <= 50; i++) {
                if (i % 10 ==0){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                subscriber.onNext(i);
            }
        }
    });
    observable.sample(2, TimeUnit.SECONDS)
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

先打印结果：

i = 9

i = 19

i = 29

i = 39

i = 49

分析：这里我们先创建了一个Observable，主要就是一个for循环，依次发射0~50，为了验证方便呢，就加了一个判断，如果发射的是整数就线程休眠5s，为什么要这样干呢，你想cpu多快啊，才50个数不是一滋溜就发射完了么，那之后通过sample(2, TimeUnit.SECONDS)设置的2s发射一个最近的值不是只有最后的一个值了么，打印的结果也就达不到验证的目的了呀。这里再附上一张图：

sample.jpg

如果我们想让它定时发射第一个元素而不是最近的一个元素，我们可以使用throttleFirst()。

Timeout

有的时候我们在规定的时间内必须要有一个数据，就上文的温度传感器来说，我们想让它每隔两秒至少发射一个，那么我们就可以用timeout函数来监听观测序列，如果在我们设定的时间内没有得到一个值就发射一个错误。

public static void main(String... args) {
    Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(Subscriber subscriber) {
            for (int i = 0; i < 50; i++) {
                if (i % 10 == 0){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                subscriber.onNext(i);
            }
        }
    })
            .timeout(2, TimeUnit.SECONDS)
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("Timeout error");
                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("i = " + integer);
                }
            });
}

打印结果：

Timeout error

可以看到，我们通过timeout(2, TimeUnit.SECONDS)设置了2s的时间限制，而在Observable中让线程休眠了2s,那么触发了Timeout，发射了一个错误。

Debounce

debounce()过滤掉了由Observable发射的速率过快的数据,如果在一个指定的时间间隔过去了仍旧没有发射一个，那么它将发射最后的那个。

public static void main(String... args) {
    Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(Subscriber subscriber) {
            for (int i = 0; i <= 50; i++) {
                if (i % 10 == 0){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                subscriber.onNext(i);
            }
        }
    })
    .debounce(2 , TimeUnit.SECONDS)
    .subscribe(new Observer() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Integer integer) {
            System.out.println("i = " + integer);
        }
    });
}

打印结果：

i = 9

i = 19

i = 29

i = 39

i = 49

从打印的结果来看，与之前的sample一般无二，但是要理解意义的不同，sample是在一条可观测序列中，选择指定时间段要发射的元素发射出来，而debounce是指一段时间内没有新数据发射，那么就发射最后的那一个。