Java中的Stream流

一、介绍

1. Stream流的作用

结合了Lambda表达式，简化集合、数组的操作。

2. Stream流的使用步骤

①先得到一条Stream流，并把数据放上去；

|--------|-----------------------------------------------------|------------------|
| 获取方式 | 方法名 | 说明 |
| 单列集合 | default Stream<E> stream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static <T> Stream<T> stream(T[] array) | Arrays工具类中的静态方法 |
| 一堆零散数据 | public static <T> Stream<T> of(T...values) | Stream接口中的静态方法 |

(1)单列集合：

java 复制代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main(String[] args) {
        // 1. 单列集合获取Stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "a", "b", "c", "d", "e");
        /*// 获取一条流水线，并把集合中的数据放到流水线上
        Stream<String> stream1 = list.stream();
        // 使用终结方法打印一条流水线上的所有数据
        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                // s：依次表示流水线上的每一个数据
                System.out.println(s);
            }
        });*/

        // 链式编程
        list.stream().forEach(s -> System.out.println(s));
    }
}

(2)双列集合

java 复制代码

import java.util.HashMap;

public class StreamDemo3 {
    public static void main(String[] args) {
        // 双列集合
        // 1. 创建双列集合
        HashMap<String, Integer> hm = new HashMap<>();
        // 2. 添加数据
        hm.put("aaa", 111);
        hm.put("bbb", 222);
        hm.put("ccc", 333);
        hm.put("ddd", 444);
        hm.put("eee", 555);
        // 3. 第一种方式 获取stream流
        hm.keySet().stream().forEach(s -> System.out.println(s));
        // 4. 第二种方式 获取stream流
        hm.entrySet().stream().forEach(s -> System.out.println(s));

    }
}

(3)数组

java 复制代码

import java.util.Arrays;
import java.util.stream.Stream;

public class StreamDemo4 {
    public static void main(String[] args) {
        // 数组获取stream流

        // 1. 创建数组
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        String[] arr2 = {"a", "b", "c"};
        // 2. 获取stream流
        Arrays.stream(arr1).forEach(s -> System.out.println(s));

        System.out.println("----------------------------------");

        Arrays.stream(arr2).forEach(s -> System.out.println(s));

        // 注意：
        // Stream接口中静态方法of的细节
        // 方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组
        // 但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当作一个元素，放到stream当中。。
        Stream.of(arr1).forEach(s -> System.out.println(s));  // [I@214c265e
        Stream.of(arr2).forEach(s -> System.out.print(s + " "));  // a b c 
    }
}

(4)一堆零散数据

java 复制代码

import java.util.stream.Stream;

public class StreamDemo5 {
    public static void main(String[] args) {
        // 一堆零散数据获取stream流

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

        Stream.of("a", "b", "c", "d", "e").forEach(s -> System.out.println(s));
    }
}

②利用中间方法对流水线上的数据进行各种操作；

注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程

注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据

|-------------------------------------------------------|----------------------------|
| 名称 | 说明 |
| Stream<T> filter(Predicate<? super<T> predicate) | 过滤 |
| Stream<T> limit(long maxSize) | 获取前几个元素 |
| Stream<T> skip(long n) | 跳过前几个元素 |
| Stream<T> distinct() | 元素去重，依赖(hashCode和equals方法) |
| static<T> Stream<T> concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
| Stream<R> map(Function<T, R> mapper) | 转换流中的数据类型 |

java 复制代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;


public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "张无忌", "张无忌", "周芷若", "赵敏", "张强", "张三丰");

        // 1. fliter 过滤 把以"张"开头的留下，其余数据过滤不要
        /*list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                // 如果返回值为true，表示当前数据留下
                // 如果返回真为false，表示当前数据舍弃不要
                return s.startsWith("张");
            }
        }).forEach(s -> System.out.println(s));*/

        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        System.out.println("------------------------------");
        System.out.println(list);  // 注意：修改Stream流中的数据，不会影响原理集合或者数组中的数据
        System.out.println("------------------------------");

        /*Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> stream2 = stream1.filter(s -> s.length() == 3);
        stream2.forEach(s -> System.out.println(s));
        Stream<String> stream3 = stream1.filter(s -> s.length() == 3);  // java.lang.IllegalStateException*/

        // 2. limit 获取前几个元素
        list.stream().limit(3).forEach(s -> System.out.println(s));
        System.out.println("------------------------------");

        // 3. skip 跳过前几个元素
        list.stream().skip(3).forEach(s -> System.out.println(s));
        System.out.println("------------------------------");

        // 4. distinct 元素去重
        list.stream().distinct().forEach(s -> System.out.println(s));
        System.out.println("------------------------------");

        // 5. concat 合并a和b两个流为一个流
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "周芷若", "赵六");
        Stream.concat(list.stream(), list2.stream()).forEach(s -> System.out.println(s));
        System.out.println("------------------------------");

        // 6. map 转换流中的数据类型
        ArrayList<String> list3 = new ArrayList<>();
        Collections.addAll(list3, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35");
        // 只获取里面的年龄并进行打印
        // 当map方法执行完毕后，流上的数据就变成了整数
        // 所以再下面的foreach当中，s一次表示流里面的每一个数据，这个数据现在就是整数了
        /*list3.stream().map(new Function<String, Object>() {
            @Override
            public Object apply(String s) {
                String[] arr = s.split("-");
                String ageString = arr[1];
                int age = Integer.parseInt(ageString);
                return age;
            }
        }).forEach(s -> System.out.println(s));
        System.out.println("------------------------------");*/

        list3.stream()
                .map(s -> Integer.parseInt(s.split("-")[1]))
                .forEach(s -> System.out.println(s));
    }
}

③使用终结方法对流水线上的数据进行操作

|-------------------------------|-------------------|
| 名称 | 说明 |
| void forEach(Consumer action) | 遍历 |
| long count() | 统计 |
| toArray() | 收集流中的数据，放到数组中 |
| collect(Collecctor collector) | 收集流中的数据，放到集合中 |

java 复制代码

import java.util.*;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.stream.Collectors;

public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");

        // 1. forEach 遍历
        // Consumer的泛型：表示流中数据的类型
        // accept方法的形参s：依次表示流里面的每一个数据
        // 方法体：对每一个数据的处理操作（打印）
       /* list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        list.stream().forEach(s -> System.out.println(s));
        System.out.println("--------------------------");

        // 2. count 统计
        long count = list.stream().count();
        System.out.println(count);
        System.out.println("--------------------------");

        // 3. toArray 收集流中的数据放到数组中
        Object[] arr1 = list.stream().toArray();
        System.out.println(Arrays.toString(arr1));
        System.out.println("--------------------------");

        // IntFunction的泛型：具体类型的数组
        // apply的形参：流中的数据的个数，要跟数组的长度保持一致
        // apply方法的返回值：具体类型的数组
        // 方法体：就是创建数组

        // toArray方法的参数的作用：负责创建一个指定类型的数组
        // toArray方法的底层：会依次得到流里面的每一个数据，并把数据放到数组当中
        // toArray方法的返回值：是一个装着流里面所有数据的数组
       /* String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(arr2));
        System.out.println("--------------------------");*/

        String[] arr3 = list.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(arr3));
        System.out.println("--------------------------");


        // 4. 收集到List集合当中
        // 需求：把所有的男性收集起来
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20", "张三丰-男-100", "张翠山-男-40", "张良-男-35");
        List<String> newList = list2.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        System.out.println(newList);
        System.out.println("--------------------------");

        // 4. 收集到Set集合当中
        // 需求：把所有的男性收集起来
        Set<String> newSet = list2.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());  // 会自动去重
        System.out.println(newSet);
        System.out.println("--------------------------");

        // 4. 收集到Map集合当中
        // 谁作为键，谁作为值。把所有的男性收集起来
        // 键：姓名 值：年龄
        // 注意点：如果我们要收集数据到Map当中，键是不能重复的
       /* Map<String, Integer> newMap = list2.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                *//*
                toMap:参数一：键的生成规则。参数二：值的生成规则
                参数一：Function泛型一：表示流中每一个数据的类型
                               泛型二：表示Map集合中键的数据类型
                       方法apply形参：依次表示流里面的每一个数据
                               方法体：生成键的代码
                               返回值：已经生成的键
                参数二：Function泛型一：表示流中每一个数据的类型
                               泛型二：表示Map集合中值的数据类型
                       方法apply形参：依次表示流里面的每一个数据
                               方法体：生成值的代码
                               返回值：已经生成的值
                 *//*
                .collect(Collectors.toMap(new Function<String, String>() {
                                              @Override
                                              public String apply(String s) {
                                                  return s.split("-")[0];  // 姓名
                                              }
                                          },
                        new Function<String, Integer>() {
                            @Override
                            public Integer apply(String s) {
                                return Integer.parseInt(s.split("-")[2]);
                            }
                        }));

        System.out.println(newMap);
        System.out.println("--------------------------");*/
        // lambda表达式
        Map<String, Integer> map2 = list2.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0]
                        ,
                        s -> Integer.parseInt(s.split("-")[2])
                ));
        System.out.println(map2);
    }
}

二、案例分析

1. 要求：按照下面的要求完成集合的创建和遍历。

①把所有以"张"开头的元素存储到新集合中；

②把"张"开头的，长度为3的元素再存储到新集合中；

③遍历打印最终结果。

java 复制代码

import java.util.ArrayList;

public class StreamDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
        // 张无忌
        // 张三丰
    }
}

2. 数据过滤

定义一个集合，并添加一些数据1，2，3，4，5，6，7，8，9，10。过滤奇数，只留下偶数，并将结果保存起来。

java 复制代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDemo8 {
    public static void main(String[] args) {
        /*
        定义一个集合，并添加一些数据1，2，3，4，5，6，7，8，9，10。
        过滤奇数，只留下偶数，并将结果保存起来。
        */

        // 1. 定义一个集合
        ArrayList<Integer> list = new ArrayList<>();
        // 2. 添加一些数据
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 3. 过滤奇数，只留下偶数
        // 进行判断，如果是偶数，返回true保留
        List<Integer> newList = list.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        // 4. 打印集合
        System.out.println(newList);
    }
}

3. 数据操作

创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄。"zhangsan, 23", "lisi, 24", "wangwu, 25"。保留年龄大于等于24岁的人，并将结果收到到Map集合中，姓名为键，年龄为值。

java 复制代码

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamDemo9 {
    public static void main(String[] args) {
        /*
        创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，
        后面是年龄。"zhangsan, 23", "lisi, 24", "wangwu, 25"。
        保留年龄大于等于24岁的人，并将结果收到到Map集合中，
        姓名为键，年龄为值。
         */

        // 1. 创建一个ArrayList集合
        ArrayList<String> list = new ArrayList<>();
        // 2. 添加以下字符串
        list.add("zhangsan, 23");
        list.add("lisi, 24");
        list.add("wangwu, 25");
        // 3. 保留年龄大于等于24岁的人
        Map<String, Integer> map = list.stream()
                .filter(s -> Integer.parseInt(s.split(", ")[1]) >= 24)
                .collect(Collectors.toMap(
                        s -> s.split(", ")[0],
                        s -> Integer.parseInt(s.split(", ")[1])));
        System.out.println(map);
    }
}

4. 数据操作

现有两个ArrayList集合，第一个集合：存储6名男演员的名字和年龄。第二个集合：存储6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如，张三，23。

要求完成下面的操作：①男演员只要名字为3个字的前两个人；②女演员只要姓杨的，并且不要第一个；③把过滤后的男演员姓名和女演员姓名合并到一起；④将上一步的演员信息封装成Actor对象；⑤将所有的演员对象都保存到List集合中。

备注：演员类Actor，属性只有一个：name，age

java 复制代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo10 {
    public static void main(String[] args) {
        /*
        现有两个ArrayList集合，第一个集合：存储6名男演员的名字和年龄。
        第二个集合：存储6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如，张三，23。
        要求完成下面的操作：①男演员只要名字为3个字的前两个人；
        ②女演员只要姓杨的，并且不要第一个；
        ③把过滤后的男演员姓名和女演员姓名合并到一起；
        ④将上一步的演员信息封装成Actor对象；⑤将所有的演员对象都保存到List集合中。
        备注：演员类Actor，属性只有一个：name，age
         */

        // 1. 创建两个ArrayList集合
        ArrayList<String> manList = new ArrayList<>();
        ArrayList<String> womenList = new ArrayList<>();
        // 2. 添加数据
        Collections.addAll(manList, "小小蔡, 24", "小小叶, 23", "小小刘, 22", "小吴, 25", "小小谷, 23", "小李, 26");
        Collections.addAll(womenList, "杨小甜, 23", "杨小小, 21", "杨小鞠, 22", "小单, 24", "刘小陈, 22", "小小曲, 23");
        // 3. 男演员只要名字为3个字的前两个人
        Stream<String> stream1 = manList.stream()
                .filter(s -> s.split(", ")[0].length() == 3)
                .limit(2);

        // 4. 女演员只要姓杨的，并且不要第一个
        Stream<String> stream2 = womenList.stream()
                .filter(s -> s.split(", ")[0].startsWith("杨"))
                .skip(1);

        // 5. 把过滤后的男演员姓名和女演员姓名合并到一起
        // 6. 将上一步的演员信息封装成Actor对象(类型转换）
        /*Stream.concat(stream1, stream2).map(new Function<String, Actor>() {
            @Override
            public Actor apply(String s) {
                String name = s.split(", ")[0];
                int age = Integer.parseInt(s.split(", ")[1]);
                return new Actor(name, age);
            }
        }).forEach(s -> System.out.println(s));*/
        List<Actor> list = Stream.concat(stream1, stream2)
                .map(s -> new Actor(s.split(", ")[0], Integer.parseInt(s.split(", ")[1])))
                .collect(Collectors.toList());
        System.out.println(list);

    }
}