【JAVA】Stream流

Stream流的三类方法

• 获取Stream流

创建一条流水线，并把数据放到流水线上准备进行操作

【获取方法】：

• 单列集合

可以使用Collection接口中的默认方法stream​()生成流

default Stream<E> stream​()

例：

        ArrayList<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.stream().forEach(s -> System.out.println(s));

• 双列集合

间接的生成流

可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流

例：

        HashMap<String,Integer> hm=new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);
        //获取键
        hm.keySet().stream().forEach(s -> System.out.println(s));
        //获取键值对对象
        hm.entrySet().stream().forEach(s -> System.out.println(s));

• 数组

Arrays中的静态方法stream 生成流

例：

int[] arr={1,2,3,4,5};
Arrays.stream(arr).forEach(s-> System.out.println(s));

• 同种数据类型的多个数据

1，2，3，4，5….

“aaa”,“bbb”,“ccc”….

使用Stream.of(T…values)生成流

例：

Stream.of(1,2,3,4,5,6,7,8).forEach(s-> System.out.println(s));

• 中间方法

流水线上的操作，一次操作完毕之后，还可以继续进行其他操作。

【常见操作方法】：

Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤（Predicate：接口中的方法）

boolean test​(T t)：对给定的参数进行判断，返回一个布尔值

Stream<T> limit​(long maxSize)：截取指定参数个数的数据

Stream<T> skip​(long n)：跳过指定参数个数的数据

static <T> Stream<T> concat​(Stream a, Stream b)：合并a和b两个流为一个流

Stream<T> distinct​()：去除流中重复的元素。依赖(hashCode和equals方法)

例：

        ArrayList<String> list=new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        //过滤流中数据
        //匿名内部类实现
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean result = s.startsWith("张");
                return result;
            }
        }).forEach(s -> System.out.println(s));
        //lambda表达式实现
        list.stream().filter((s -> {
            boolean result = s.startsWith("张");
            return result;
        })).forEach(s -> System.out.println(s));
        //lambda表达式实现（简化）
        list.stream().filter(s->s.startsWith("张")).forEach(s -> System.out.println(s));
        //截取流
        list.stream().limit(2).forEach(s -> System.out.println(s));
        //跳过流
        list.stream().skip(2).forEach(s -> System.out.println(s));
        ArrayList<String> list2=new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无忌");
        list2.add("张翠山");
        list2.add("王二麻子");
        list2.add("张良");
        list2.add("谢广坤");
        //合并流
        Stream<String> stream1=list.stream();
        Stream<String> stream2=list2.stream();
        Stream<String> stream3=Stream.concat(stream1,stream2);
        stream3.forEach(s -> System.out.println(s));
        //合并流（简化）
        Stream.concat(list.stream(),list2.stream()).forEach(s -> System.out.println(s));
        //删除流中重复元素
        list.stream().distinct().forEach(s -> System.out.println(s));

• 终结方法

一个Stream流只能有一个终结方法，是流水线上的最后一个操作

【常见终结方法】：

void forEach​(Consumer action)：对此流的每个元素执行操作（Consumer接口中的方法） 

void accept​(T t)：对给定的参数执行此操作

long count​()：返回此流中的元素数

例：

        ArrayList<String> list=new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        //匿名内部类实现
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //lambda表达式实现
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        //lambda表达式实现（简化）
        list.stream().forEach(s -> System.out.println(s));
        //返回流中的元素个数
        System.out.println(list.stream().count());

Stream流的收集

【收集方法】：

R collect​(Collector collector)

工具类Collectors提供了具体的收集方式：

• public static <T> Collector toList​()：把元素收集到List集合中
• public static <T> Collector toSet​()：把元素收集到Set集合中
• public static  Collector toMap​(Function keyMapper,Function valueMapper)：把元素收集到Map集合中

例：

1、将ArrayList集合中的数字1-10，筛选出偶数并添加到新的集合中

        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.add(10);
        list.add(10);
        //把元素收集到List集合中(匿名内部类)
        list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                boolean result= integer%2==0;
                return result;
            }
        }).forEach(s-> System.out.println(s));
        //把元素收集到List集合中(lambda表达式)
        List<Integer> list1 = list.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());
        System.out.println(list1);

        //把元素收集到Set集合中
        Set<Integer> set = list.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());
        System.out.println(set);

2、将ArrayList集合中的Student学生类信息（前面是姓名后面是年龄）经过年龄筛选并添加至新的Map集合中

        ArrayList<Student> list=new ArrayList<>();
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //把元素收集到Map集合中(匿名内部类)
        Map<String, Integer> studentMap = list.stream().filter(new Predicate<Student>() {
            @Override
            public boolean test(Student student) {
                boolean result = student.getAge() >= 24;
                return result;
            }
        }).collect(Collectors.toMap(Student::getName, Student::getAge));
        System.out.println(studentMap);
        //把元素收集到Map集合中(lambda表达式)
        Map<String, Integer> studentMap1 = list.stream().filter(student -> student.getAge() >= 24)
                .collect((Collectors.toMap(Student::getName, Student::getAge)));
        System.out.println(studentMap1);

3、将ArrayList集合中的String类信息（前面是姓名后面是年龄）经过年龄筛选并添加至新的Map集合中

        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");
        //把元素收集到Map集合中(匿名内部类)
        Map<String, Integer> studentMap = list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                String[] arr = s.split(",");
                int age = Integer.parseInt(arr[1]);
                boolean result = age >= 24;
                return result;
            }
        }).collect(Collectors.toMap(s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1]
                )));
        System.out.println(studentMap);
        //把元素收集到Map集合中(lambda表达式)
        Map<String, Integer> studentMap1 = list.stream().filter(
                s -> {
                    String[] arr = s.split(",");
                    int age = Integer.parseInt(arr[1]);
                    return age >= 24;
                }
        ).collect(Collectors.toMap(s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1]
                )));
        System.out.println(studentMap1);