JDK8（StreamApi）

1，介绍

【1】理解

• 把集合变成一个流， 条件变成一个管道 。满足条件就下来。

• 实现场景以后拿到网络请求的数据，不需要再次请求数据进行服务器排序，可以直接对集合进行操作

没有对原始数据进行变化。  

 

2，Stream对集合进行一些操作

【1】遍历集合 

• JDK1.8以前遍历集合的方法

 

    @RequiresApi(api = Build.VERSION_CODES.N)

    private static void foreach() {

        List<Integer> list = Arrays.asList(1, 2, 3);

        for (int i = 0; i < list.size(); i++) {

                System.out.println(list.get(i));

        }

•  jdk8提供的遍历集合

 

   Stream<Integer> stream = list.stream();

        stream.forEach(new Consumer<Integer>() {

            @Override

            public void accept(Integer integer) {

                System.out.println(integer);

            }

        });

•  使用Lambda表达式简化遍历方法 

  // 高级迭代期

        list.stream()

                .forEach(i->System.out.println(i));

    }

【2】过滤集合，只要奇数

• filter进行过滤，forEach进行循环打印

   

list.stream()

            .filter(new Predicater<Integer>()){

            @Override

            public boolean test(Integer integer){

            return; integer%2!=0;

        }

    }})

    .forEach(new Consumer<Integer>() {

        @Override

        public void accept(Integer integer) {

            System.out.println(integer);

        }

});

• 用lambda方法

List<Integer> list = Arrays.asList(1, 2, 3);

// 过滤集合，只要奇数

// 把集合转换成流

list.stream()

        // 过滤集合

        .filter(i->i%2!=0)

        .forEach(System.out::println);

 

 

【3】默认排序 从小

  @RequiresApi(api = Build.VERSION_CODES.N)

    private static void sort() {

        List<Integer> list = Arrays.asList(5, 2, 3,1,4);

        list.stream()

                // 默认排序从小到大

                .sorted()

                .forEach(System.out::println);

    }

【4】自定义排序 

正序：integer-他

倒序 ：t1-integer; 

 @RequiresApi(api = Build.VERSION_CODES.N)

    private static void sort() {

        List<Integer> list = Arrays.asList(5, 2, 3,1,4);

        list.stream()

                // 排序

                .sorted(new Comparator<Integer>() {

                    @Override

                    public int compare(Integer integer, Integer t1) {

                        return t1-integer;

                    }

                })

                .forEach(System.out::println);

    }

 

【5】去除重复

@RequiresApi(api = Build.VERSION_CODES.N)

private static void distinct() {

    List<Integer> list = Arrays.asList(5, 2, 3,5,2);

    list.stream()

            // 去重

            .distinct()

            .forEach(System.out::println);

}

【6】统计操作

@RequiresApi(api = Build.VERSION_CODES.N)

private static void sum() {

    List<Integer> list = Arrays.asList(5, 2, 3,5,2);

    IntSummaryStatistics intSummaryStatistics = list.stream()

            // 统计

            .mapToInt(i -> i)

            .summaryStatistics();

    System.out.println(intSummaryStatistics);

}

• 打印操作

 

【7】一对一的转换

• Integer 是需要转换的类型

• String 想要变成的类型

@RequiresApi(api = Build.VERSION_CODES.N)

private static void map() {

    List<Integer> list = Arrays.asList(5, 2, 3,5,2);

    list.stream()

            // 转换 一对一，每一个数据都会经历map转换成新的数据

            .map(new Function<Integer, String>() {

                @Override

                public String apply(Integer integer) {

                    return integer+"转换";

                }

            })

            .forEach(System.out::println);

}

• 输出结果

 

【8】一对多转换（相当于二维数组）

• 类似于集合里面放集合

@RequiresApi(api = Build.VERSION_CODES.N)

private static void flatmap() {

    List<Integer> list1 = Arrays.asList(5, 2, 3,5,2);

    List<Integer> list2 = Arrays.asList(1, 2);

    List<Integer> list3 = Arrays.asList(7,8);

    List<List<Integer>> lists = Arrays.asList(list1, list2, list3);

    lists.stream()

            .flatMap(new Function<List<Integer>, Stream<?>>() {

                @Override

                public Stream<?> apply(List<Integer> integers) {

                    return integers.stream();

                }

            })

    .forEach(System.out::println);

}