[Java笔记17] Stream流

目录

Stream的三类方法

获取Stream流

Stream流常用的中间操作方法

Stream流的常见终结操作方法​

Stream的收集操作

---

视频教程传送门 -> https://www.bilibili.com/video/BV1Cv411372m?p=137

Stream => 用于简化集合和数组操作的API，结合了Lambda表达式

Stream流式思想的核心：
先得到集合或者数组的Stream流（类似传送带）-> 把元素放上去 -> 然后就用这个Stream流简化的API来方便的操作元素（支持链式编程）
 

Stream的三类方法

获取Stream => 创建一条流水线，并把数据放到流水线上准备进行操作
中间方法 => 流水线上的操作，一次操作完毕之后，还可以继续进行其他操作
终结方法 => 一个Stream只能有一个终结方法，是流水线上的最后一个操作

Stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。

获取Stream流

Collection集合获取流
Collection<String> list = new ArrayList<>();
Stream<String> s = list.stream();

Map集合获取流
Map<String, Integer> maps = new HashMap<>();
//键
Stream<String> keyStream = maps.keySet().stream();
//值
Stream<Integer> valueStream = maps.values().stream();
//键值对
Stream<Map.Entry<String,Integer>> keyAndValueStream =  maps.entrySet().stream();

数组获取流
String[] names = {"赵敏","小昭","阿离","芷若"};
Stream<String> nameStream = Arrays.stream(names);
Stream<String> nameStream2 = Stream.of(names);

Stream流常用的中间操作方法

注意：
中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程。
在Stream流中无法直接修改集合、数组中的数据。

Stream流的常见终结操作方法

 注意：终结操作方法，调用完成不会返回Stream => 流无法继续使用了

 【例】Stream常用API

package com.test.d2_stream;

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

/**
     Stream流的常用API
         forEach : 逐一处理(遍历)
         count：统计个数
            -- long count();
         filter : 过滤元素
            -- Stream<T> filter(Predicate<? super T> predicate)
         limit : 取前几个元素
         skip : 跳过前几个
         map : 加工方法
         concat : 合并流
 */
public class StreamDemo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("杨过");
        list.add("杨不悔");
        list.add("张三丰");
        list.add("杨铁心");

        // Stream<T> filter(Predicate<? super T> predicate)
        System.out.println("1、输出杨姓人物");
        list.stream().filter(s -> s.startsWith("杨")).forEach(s -> System.out.println(s));

        System.out.println("2、输出姓名三字的人物个数");
        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size);

        System.out.println("3、输出前两个杨姓人物");
        // list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("杨")).limit(2).forEach(System.out::println);

        System.out.println("4、输出杨姓人物跳过前两个");
        list.stream().filter(s -> s.startsWith("杨")).skip(2).forEach(System.out::println);

        // map加工方法: 第一个参数原材料  -> 第二个参数是加工后的结果。
        System.out.println("5、给人物加上\"金庸笔下的\"");
        list.stream().map(s -> "金庸笔下的" + s).forEach(a -> System.out.println(a));

        // 需求：把所有的名称 都加工成一个人物对象。
        System.out.println("6、把人物加共为人物对象");
        list.stream().map(s -> new Figure(s)).forEach(s -> System.out.println(s));
        //list.stream().map(Figure::new).forEach(System.out::println); // 构造器引用  方法引用

        // 合并流
        System.out.println("7、合并流");
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("郭靖", "杨过", "张无忌");
        // public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
        Stream<String> s3 = Stream.concat(s1 , s2);
        s3.distinct().forEach(s -> System.out.println(s));
    }
}

输出：

1、输出杨姓人物
杨过
杨不悔
杨铁心
2、输出姓名三字的人物个数
5
3、输出前两个杨姓人物
杨过
杨不悔
4、输出杨姓人物跳过前两个
杨铁心
5、给人物加上"金庸笔下的"
金庸笔下的张无忌
金庸笔下的周芷若
金庸笔下的赵敏
金庸笔下的杨过
金庸笔下的杨不悔
金庸笔下的张三丰
金庸笔下的杨铁心
6、把人物加共为人物对象
Figure{name='张无忌'}
Figure{name='周芷若'}
Figure{name='赵敏'}
Figure{name='杨过'}
Figure{name='杨不悔'}
Figure{name='张三丰'}
Figure{name='杨铁心'}
7、合并流
张无忌
张三丰
郭靖
杨过

Stream的收集操作

收集Stream流，就是把Stream流操作后的结果数据转回到集合或者数组中去

【例】

package com.test.d2_stream;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

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

        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        List<String> zhangList = s1.collect(Collectors.toList()); // 可变集合
        zhangList.add("张翠山");
        System.out.println(zhangList);

       //List<String> list1 = s1.toList(); // 得到不可变集合
       //list1.add("金毛狮王"); //添加元素会报错
       //System.out.println(list1);

        // 注意：流只能使用一次
        Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
        Set<String> zhangSet = s2.collect(Collectors.toSet());
        System.out.println(zhangSet);

        Stream<String> s3 = list.stream().filter(s -> s.startsWith("张"));
//      Object[] arrs = s3.toArray();
        String[] arrs = s3.toArray(s -> new String[s]); //如果一定要转成字符串类型
        //String[] arrs = s3.toArray(String[]::new); //与前一行作用相同
        System.out.println("Arrays数组内容：" + Arrays.toString(arrs));

    }
}

输出：
[张无忌, 张三丰, 张三丰, 张翠山]
[张三丰, 张无忌]
Arrays数组内容：[张无忌, 张三丰, 张三丰]
注意：
1）流只能使用一次
2）s1.collect(Collectors.toList()得到可变集合；s1.toList()得到不可变集合