Rxjava过滤函数

过滤的几个基本操作  filter disctinct first last take takeFirst takeLast skip SkipLast elementAt ingnoreEelements debounce

（1）distinct 去除重复操作  去除重复操作，根据具体的值进行去除重复，如果是对象的化，则比较的是对象，则比较的是地址

package rxjava.filter;

import io.reactivex.Observable;
import rxjava.map.PersonModel;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class RxjavaDistinct {

    public static void main(String[] args) {
        //去除重复
        Observable.just(1,4,3,1,2,3,4,5,6).distinct().sorted().subscribe(x->System.out.println(x));
        System.out.println("==================");

        Observable.just(1,1,1,2,2,3,3,2).distinctUntilChanged().subscribe(x->System.out.println(x));

        System.out.println("==================");
        List<PersonModel> list=new ArrayList<>();
        PersonModel personModel=new PersonModel();
        personModel.setName("zhangsan");
        personModel.setScores(new ArrayList<>(Arrays.asList(11,22,33)));
        list.add(personModel);
        PersonModel personModel1=new PersonModel();
        personModel1.setName("lisi");
        personModel1.setScores(new ArrayList<>(Arrays.asList(22,33,44)));
        list.add(personModel1);

        Observable.fromIterable(list).map(m->m.getName()).sorted().distinct().subscribe(x->System.out.println(x));



    }
}

1
2
3
4
5
6
==================
lisi
zhangsan

2.filter  过滤出满足条件的数据项
 

package rxjava.filter;

import io.reactivex.Observable;

public class RxjavaFilter {
    public static void main(String[] args) {
        Observable.range(1,10).filter(f->f % 2 ==0).subscribe(x->System.out.println(x));
    }
}

2
4
6
8
10

3、first 找到满足条件的第一个数据项

package rxjava.filter;

import io.reactivex.Observable;

public class RxjavaFirst {

    public static void main(String[] args) {
        Observable.range(1,10).first(1).subscribe(x->System.out.println(x));
    }
}

1

4、last  找到满足条件的最后一个数据项

package rxjava.filter;


import io.reactivex.Observable;

public class RxjavaLast {
    public static void main(String[] args) {
        Observable.range(1,10).last(1).subscribe(x->System.out.println(x));
    }
}

10

5 take 只发送前n个数据项 后面的数据项忽略

package rxjava.filter;

import io.reactivex.Observable;

public class RxjavaTake {
    public static void main(String[] args) {
        Observable.range(1,10).take(3).subscribe(x->System.out.println(x));
    }
}

1
2
3

6 takeLast   取数据项的最后几个值  

package rxjava.filter;

import io.reactivex.Observable;

public class RxjavaTakeLast {
    public static void main(String[] args) {
        Observable.range(1,10).takeLast(3).subscribe(x->System.out.println(x));
    }
}

8
9
10

7 skip 跳过观察到第n项发射 跳过n个 到n+1

package rxjava.filter;

import io.reactivex.Observable;

public class RxjavaSkip {
    public static void main(String[] args) {
        Observable.range(1,10).skip(3).subscribe(x->System.out.println(x));
    }
}

4
5
6
7
8
9
10

8 skipLast  跳过最后n个 。将早调用onComplete事件之前跳过最后指定数量的数据项

package rxjava.filter;

import io.reactivex.Observable;

public class RxjavaSkipLast {

    public static void main(String[] args) {
        Observable.range(1,10).skipLast(3).subscribe(x->System.out.println(x));
    }
}

1
2
3
4
5
6
7

9 elementAt 紧紧发射第n个数据项目  返回值 MayBe

package rxjava.filter;

import io.reactivex.MaybeObserver;
import io.reactivex.Observable;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

public class RxJavaElementAt {

    public static void main(String[] args) {
        Observable.range(1,10).elementAt(4).subscribe(x->System.out.println(x));

        Observable.range(1,10).elementAt(12,10).subscribe(x->System.out.println(x));

        Observable.range(1,10).elementAtOrError(12).subscribe(new SingleObserver<Integer>() {


            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(Integer integer) {

            }

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


    }
}

5
10
java.util.NoSuchElementException

10 ignoreelements 不发送任何数据项 只发送Observable的终止通知

package rxjava.filter;

import io.reactivex.CompletableObserver;
import io.reactivex.Observable;
import io.reactivex.disposables.Disposable;

public class RxjavaIngnoreElements {
    public static void main(String[] args) {
        Observable.range(1,10).ignoreElements().subscribe(new CompletableObserver() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onComplete() {
                System.out.println("CompletableObserver.onComplete");
            }

            @Override
            public void onError(Throwable e) {

            }
        });
    }
}

CompletableObserver.onComplete

11  debounce 仅在一段时间还没发送数据时 才发送一个数据项

package rxjava.filter;

import io.reactivex.Observable;

import java.util.concurrent.TimeUnit;

public class RxjavaDebounce {

    public static void main(String[] args) {
        Observable.range(1,10).debounce(3, TimeUnit.SECONDS).subscribe(x->System.out.println(x));
    }
}

10