Stream流

Stream流

Stream流的获取方法

单列集合
　　可以使用Collection接口中的默认方法stream?()生成流
　　default Stream<E> stream()
双列集合
　　间接的生成流
　　可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
数组
　　Arrays中的静态方法stream 生成流
同种数据类型的多个数据（1，2，3….或“aaa”,“bbb”,“ccc”….）
　　使用Stream.of(T…values)生成流

public static void main(String[] args) {
    //单列集合
    ArrayList<String> list = new ArrayList<>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");

    //Stream<String> stream = list.stream();
    //stream.forEach(s-> System.out.println(s));
    list.stream().forEach(s-> System.out.println(s)); //aaa bbb ccc

    //双列集合
    HashMap<String,Integer> hm = new HashMap<>();
    hm.put("zhangsan",23);
    hm.put("list",24);
    hm.put("wangwu",25);
    //双列集合不能直接获取Stream流
    //keySet：先获取到所有的键；再把这个Set集合中所有的键放到Stream流中
    hm.keySet().stream().forEach(s-> System.out.println(s)); //zhangsan wangwu list

    //entrySet：先获取到所有的键值对对象；再把这个Set集合中所有的键值对对象放到Stream流中
    hm.entrySet().stream().forEach(s-> System.out.println(s)); //zhangsan=23 wangwu=25 list=24

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

    //同种数据类型的多个数据
    Stream.of(1,2,3).forEach(s-> System.out.println(s)); //1 2 3
}

Stream流的常见中间操作方法

Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
　　Predicate接口中的方法：boolean test(T t)：对给定的参数进行判断，返回一个布尔值

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三丰");
    list.add("张无忌");
    list.add("王二麻子");
    list.add("张良");
    list.add("谢广坤");
    //filter方法获取流中的每一个数据。而test方法中的s,就依次表示流中的每一个数据。我们只要在test方法中对s进行判断就可以了。
    //如果判断的结果为true,则当前的数据留下
    //如果判断的结果为false,则当前数据就不要
    //list.stream().filter(
    //        new Predicate<String>() {
    //            @Override
    //            public boolean test(String s) {
    //                boolean result = s.startsWith("张");
    //                return result;
    //            }
    //        }
    //).forEach(s-> System.out.println(s));

    //因为Predicate接口中只有一个抽象方法test，所以我们可以使用lambda表达式来简化
    //list.stream().filter(
    //        (String s)->{
    //            boolean result = s.startsWith("张");
    //                return result;
    //        }
    //).forEach(s-> System.out.println(s));
    //最简版
    list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
}

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方法)

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三丰");
    list.add("张无忌");
    list.add("谢广坤");
    list.add("谢广坤");
    //Stream<T> limit(long maxSize)：截取指定参数个数的数据
    //list.stream().limit(2).forEach(s-> System.out.println(s)); //张三丰 张无忌

    //Stream<T> skip(long n)：跳过指定参数个数的数据
    //list.stream().skip(2).forEach(s-> System.out.println(s)); //谢广坤 谢广坤

    //static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
    ArrayList<String> list2 = new ArrayList<>();
    list2.add("张三丰1");
    list2.add("张无忌1");
    list2.add("谢广坤1");

    //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));//张三丰 张无忌 谢广坤 谢广坤 张三丰1 张无忌1 谢广坤1

    //Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
    list.stream().distinct().forEach(s-> System.out.println(s)); //张三丰 张无忌 谢广坤
}

Stream流的常见终结操作方法

void forEach(Consumer action)：对此流的每个元素执行操作
　　Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
long count()：返回此流中的元素数

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三丰");
    list.add("张无忌");
    list.add("张良");
    //void forEach(Consumer action)：对此流的每个元素执行操作
    //在forEach方法的底层,会循环获取到流中的每一个数据,并循环调用accept方法,并把每一个数据传递给accept方法,s就依次表示了流中的每一个数据.所以,只要在accept方法中,写上处理的业务逻辑就可以了.
    list.stream().forEach(
            new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println(s);
                }
            }
    );
    //lambda表达式的简化格式
    //是因为Consumer接口中,只有一个accept方法
    list.stream().forEach(
            (String s)->{
                System.out.println(s);
            }
    );
    //lambda表达式进一步简化
    list.stream().forEach(s->System.out.println(s));

    //long count()：返回此流中的元素数
    long count = list.stream().count();
    System.out.println(count);  //3
}

Stream流的收集操作

在Stream流中无法直接修改集合、数组等数据源中的数据

R collect(Collector collector)   获取流中剩余的数据,但是不负责创建容器,也不负责把数据添加到容器中

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

public static <T> Collector toList()　　把元素收集到List集合中
public static <T> Collector toSet()　　把元素收集到Set集合中

//定义一个集合，并添加一些整数1,2,3,4,5,6,7,8,9,10。将集合中的奇数删除，只保留偶数。遍历集合得到2，4，6，8，10
public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<>();
    for (int i = 1; i <= 10; i++) {
        list1.add(i);
    }
    list1.add(10); //加此句用于验证toList与toSet区别，toSet不可重复

    //filter负责过滤数据
    //collect负责收集数据
    //Collectors.toList() :在底层会创建一个List集合.并把所有的数据添加到List集合中.
    List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
            .collect(Collectors.toList());
    System.out.println(list); //[2, 4, 6, 8, 10, 10]
    
    //Collectors.toSet() :在底层会创建一个Set集合.并把所有的数据添加到Set集合中.
    Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
            .collect(Collectors.toSet());
    System.out.println(set); //[2, 4, 6, 8, 10]
}

public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中

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

    Map<String, Integer> map = list.stream().filter(
            s -> {
                String[] split = s.split(",");
                int age = Integer.parseInt(split[1]);
                return age >= 24;
            }
            //Collectors.toMap 创建一个map集合并将数据添加到集合当中
            //第一个lambda表达式就是如何获取到Map中的键
            //第二个lambda表达式就是如何获取Map中的值
    ).collect(Collectors.toMap(
            s -> s.split(",")[0],
            s -> Integer.parseInt(s.split(",")[1])
    ));
    System.out.println(map); //{lisi=24, wangwu=25}
}