rxjava 与 kotlin filter/groupBy/（flatten） 对比

filter

rxjava :

@Test
public void test3() {
    ArrayList<Integer> integers = new ArrayList<>();
    for (int i = 0; i < 6; i++) {
        integers.add(i);
    }

    Observable.fromIterable(integers)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    return integer % 2 == 0;
                }
            })
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("integer=======" + integer);
                }
            });
}
//integer=======0
//integer=======2
//integer=======4

kotlin :

@Test
fun test3() {
    val list = listOf(1, 2, 3, 3, 4, 5, 6)
    list.filter {
        it % 2 == 0
    }.forEach {
        println(it)
    }
}
//2
//4
//6

groupBy

rxjava :

@Test
public void test2() {
    ArrayList<Integer> integers = new ArrayList<>();
    for (int i = 0; i < 6; i++) {
        integers.add(i);
    }

    Observable.fromIterable(integers)
            .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(GroupedObservable<String, Integer> groupedObservable) {
                    final String key = groupedObservable.getKey();
                    groupedObservable.subscribe(new Consumer<Integer>() {
                        @Override
                        public void accept(Integer integer) throws Exception {
                            System.out.println("key:" + key + " = " + "value:" + integer);
                        }
                    });
                }
            });
}
//key:偶数 = value:0
//key:奇数 = value:1
//key:偶数 = value:2
//key:奇数 = value:3
//key:偶数 = value:4
//key:奇数 = value:5

kotlin :

@Test
fun test2() {
    val list = listOf(1, 2, 3, 4, 5, 6)
    list.groupBy {
        if (it % 2 == 0) {
            "偶数"
        } else {
            "奇数"
        }
    }.forEach {
        println(it)
        val key = it.key
        val value = it.value
        println("key:$key === value: $value")
        value.forEach {
            println("遍历value：$it ")
            println("-------------------")
        }
        println("============================")
    }
}
//奇数=[1, 3, 5]
//key:奇数 === value: [1, 3, 5]
//遍历value：1 
//-------------------
//遍历value：3 
//-------------------
//遍历value：5 
//-------------------
//============================
//偶数=[2, 4, 6]
//key:偶数 === value: [2, 4, 6]
//遍历value：2 
//-------------------
//遍历value：4 
//-------------------
//遍历value：6 
//-------------------
//============================

（flatten）： 组装集合

rxjava

@Test
public void test1() {
    ArrayList<Integer> integers = new ArrayList<>();
    integers.add(1);
    integers.add(2);
    integers.add(3);
    integers.add(4);
    Observable.fromIterable(integers)
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("fromIterable integer======" + integer);
                }
            });


    ArrayList<Integer> integers1 = new ArrayList<>();
    integers1.add(1);

    ArrayList<Integer> integers2 = new ArrayList<>();
    integers1.add(2);

    ArrayList<Integer> integers3 = new ArrayList<>();
    integers1.add(3);

    ArrayList<Integer> integers4 = new ArrayList<>();
    integers1.add(4);

    Observable.fromArray(integers1, integers2, integers3, integers4)
            .flatMap(new Function<ArrayList<Integer>, ObservableSource<Integer>>() {
                @Override
                public ObservableSource<Integer> apply(ArrayList<Integer> integers) throws Exception {
                    return Observable.fromIterable(integers);
                }
            })
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("fromArray integer======" + integer);
                }
            });
}
//fromIterable integer======1
//fromIterable integer======2
//fromIterable integer======3
//fromIterable integer======4
//fromArray integer======1
//fromArray integer======2
//fromArray integer======3
//fromArray integer======4 

kotlin:

@Test
fun test1() {
    val list1 = listOf(1, 2, 3, 4)
    list1.forEach {
        println("单纯列表========$it")
    }

    val list2 = listOf(listOf(1), listOf(2), listOf(3), listOf(4)).flatten()
    list2.forEach {
        println("flatten四个列表===========$it")
    }
}
单纯列表========1
单纯列表========2
单纯列表========3
单纯列表========4
flatten四个列表===========1
flatten四个列表===========2
flatten四个列表===========3
flatten四个列表===========4