Stream流式编程详解

Posted 2022-09-24

一、概述

将集合或数组 转换成一种流的元素序列。流不是集合中的元素，也不是一种数据结构，不负责数据的存储。Stream 流也不会改变源对象（源集合）Stream 接口中几乎所有方法的参数都是四大函数式接口接口类型的参数。而函数式接口可以使用 lambda 表达式来简化开发，并且 Stream 接口中的方法基本都是返回对象本身（返回对象本身的方法可以使用链式编程）。所以在使用 Stream 流式计算时，基本上都用到了函数式接口、lambda表达式 和 链式编程。

1.1、特性： 不存储数据、不改变数据源、不可重复使用

可以看作一根管道，用于数据的转换，所以不会存储数据，也不会影响原来的数据。因为stream是一根管道，不可重复使用就是stream用完一次之后，数据就输出了

Stream stream1 = Stream.of(1,2,3);
        
 //创建stream2过滤stream1
 Stream stream2 =  stream1.filter(s->s.equals(1));

 //下句代码会出错，因为stream1流用过一次，消失了
 Stream stream3 =  stream1.filter(s->s.equals(1));

1.2、生成流的方式

Array.stream()-用于基本类型

parallelStream() 是并行流方法，并行流就是把内容分成多个数据块，使用不同的线程分别处理每个数据块的流。

Arrays.stream(new int[]1,2,3); //使用Array的静态方法创建流

但要注意的是，不是所有情况的适合，有些时候并行甚至比顺序进行效率更低，而有时候因为线程安全问题，还可能导致数据的处理错误，因此并行的性能问题非常值得我们思考。下面这个例子就比较慢，因为JVM对基本类型还要装箱开箱操作，不如直接串行计算了

int i = Stream.iterate(1, a -> a + 1).limit(100).parallel().reduce(0, Integer::sum);

Stream.of()-用于任何类型

Stream.of(1,"小明",2,new ArrayList<>()); //使用Stream的静态方法创建流

Stream.iterate-函数流

//iterate() ： 依次对每个新生成的值应用函数; generate() ：接受一个函数，生成一个新的值

//生成流，首元素为 0，之后依次加 2
Stream.iterate(0, n -> n + 2)
//生成流，为 0 到 1 的随机双精度数
Stream.generate(Math :: random)
//生成流，元素全为 1
Stream.generate(() -> 1)

Files.lines()-用于文件流

Stream stream = Files.lines(Paths.get(“data.txt”));

XXX.stream()-用于集合

Collection collection  = new ArrayList();

collection.stream(); // 使用Collection类里的成员方法stream()方式创建流

1.3、反转流到集合

一般是用Stream.collect()的方法来实现的，下面给一个转为List的例子

public static void main(String[] args) 
    // 将数组变成一个列表集合
    List<Integer> list = Arrays.asList(14, 3, 5, 7, 12);
    // List集合获取 Stream 流
    Stream<Integer> stream = list.stream();
    // 操作 Stream 流
    List<Integer> collect = stream
                                // 获取 > 5 的元素
                                .filter((i) ->  return i > 5; )
                                // 对元素进行升序排序
                                .sorted()
                                // 将 Stream 流转换成 List 集合
                                .collect(Collectors.toList());
    // 遍历 转换后的 List 集合
    for (Integer i : collect) 
        System.out.println(i);
    

二、中间节点与终值节点

2.1、中间节点

懒节点不会自动执行，所以下例代码不会打印hello

public static void main(String[] args) 
        List list = new ArrayList();

        Stream.of(list).filter(a->
            System.out.println("hello");
            return true;
        ); //没有打印结果

2.2、终值节点

这时在最后加了.toArray()方法，相当于加上了终值节点，那么此时终值节点+前面的节点都会执行

public static void main(String[] args) 
        List list = new ArrayList();

        Stream.of(list).filter(a->
            System.out.println("hello");
            return true;
        ).toArray(); //打印输出hello

可以查看Stream的API，如果方法的返回值为Stream<T>的基本都是中间节点

三、Stream的方法

常用的方法如下：

• 中间节点：filter()、map()、mapToInt()、flatMap()、sorted()、peek()、reduce()、distinct()
• 终值节点：forEach()、toArray()、collect()

@Data
public class AppleStore 
    int id; //编号
    String color; //颜色
    double weight; //重量
    String origin; //产地

3.1、迭代：peek()

public class StreamTest 
    private static List<AppleStore> appleStores = new ArrayList();

    static 
        appleStores.add(new AppleStore(1,"red",1.2,"重庆"));
        appleStores.add(new AppleStore(2,"red",1.5,"四川"));
        appleStores.add(new AppleStore(3,"yellow",2.6,"重庆"));
        appleStores.add(new AppleStore(4,"yellow",2.9,"四川"));
        appleStores.add(new AppleStore(5,"red",3.2,"杭州"));
    
    public static void main(String[] args) 

        //peek()是执行每个节点的方法
        //peek里的方法会挨个执行，也就是节点会挨个执行，也称作责任链模式
    appleStores.stream().peek(appleStore -> System.out.println(appleStore.getColor())) //打印苹果的颜色
            .peek(appleStore -> System.out.println(appleStore.getWeight())) //打印苹果的重量
            .peek(appleStore -> System.out.println(appleStore.getOrigin())) //打印苹果的产地
            .toArray();
    

red1.2重庆
red1.5四川
yellow2.6重庆
yellow2.9四川
red3.2杭州

3.2、终点：foreach()

foreach功能和peek相同，不同是foreach是终值节点，也就是不能再往下继续执行，但执行的结果是和上面是一样的。

appleStores.stream().peek(apple -> System.out.println(apple.getColor())) //打印苹果编号
        .peek(apple -> System.out.println(apple.getWeight())) //打印苹果颜色
        .forEach(sout-> System.out.println(sout.getOrigin()));
red1.2重庆
red1.5四川
yellow2.6重庆
yellow2.9四川
red3.2杭州

3.3、流式处理

3.3.1、过滤：filter(Predicate predicate)

@Test
public void name2() 
    appleStores.stream().filter(appleStore -> appleStore.getColor().equals("red")) //过滤出红色的苹果
            .peek(appleStore -> System.out.println(appleStore)) //到第二个节点只有红色苹果的数据了
            .toArray();

AppleStore(id=1, color=red, weight=1.2, origin=重庆)
AppleStore(id=2, color=red, weight=1.5, origin=四川)
AppleStore(id=5, color=red, weight=3.2, origin=杭州)

3.3.2、转换：map(Function<? super T, ? extends R> mapper)

@Test
public void name3() 
    //此时数据全部变成了String字符串 因为map中的方法是getColor()，映射成为的是String，对象Stream<String>
    appleStores.stream().map(appleStore -> appleStore.getColor()) //获取苹果的颜色
            .peek(color -> System.out.print(color+"--"))//循环的是Stream<String>
            .toArray();


red--red--yellow--yellow--red--

3.3.3、去重：distinct()

@Test
public void name4() 
    appleStores.stream().map(appleStore -> appleStore.getColor()) //获取苹果的颜色
            .distinct() //去重
            .peek(color -> System.out.print(color+"--"))
            .toArray();


red--yellow

3.3.4、排序：Comparator<? super T> comparator

@Test
public void name5() 
    List<Integer> collect = appleStores.stream() // 获取appleStores的流
            .map(appleStore -> appleStore.getId()) // 转换功能：获取id，从List<AppleStore>转换成了List<int>
            
            // 从小到大排序 (本质是调用compareTo()方法，所以类要实现CompareAble接口)
            .sorted() 
            //从大到小排序
            .sorted(Comparator.reverseOrder())
            
            // 多字段排序，升序排序（先根据年龄排序，如果年龄相同，则年龄相同的用户根据 id 排序），多字段需要自己实现，也可以用自带的API排序
            .sorted(Comparator.comparing(User::getAge).thenComparing(User::getId))
            .limit(3) // 取前三个元素
            
            .collect(Collectors.toList()); //将stream流转回List集合
    System.out.println(collect);

3.3.5、截取：limit(long maxSize) 截取（截取前面n个元素）

public static void main(String[] args) 
    // 将数组变成一个列表集合
    List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);

    // 获取集合的 Stream 流对象
    list.stream()
        // 截取（截取前面前4个元素）
        .limit(4)
        // 遍历
        .forEach(System.out::println);

3.3.6、丢弃：skip(long n) 丢弃（丢弃前面n个元素）

public static void main(String[] args) 
    // 将数组变成一个列表集合
    List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);

    // 获取集合的 Stream 流对象
    list.stream()
        // 丢弃（丢弃前面4个元素）
        .skip(4)
        // 遍历
        .forEach(System.out::println);

3.3.7、计数：count() 计数（返回流中元素个数）

public static void main(String[] args) 
    // 将数组变成一个列表集合
    List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);
    // 获取集合的 Stream 流中元素个数
    long count = list.stream().count();

3.3.8、拼接：concat(Stream<? extends T> a, Stream<? extends T> b) 拼接（对两个流对象进行拼接）

public static void main(String[] args) 
    // 将数组变成一个列表集合
    List<Integer> list_01 = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> list_02 = Arrays.asList(6, 7, 8, 9, 0);
    // 将两个 Stream 流拼接（首尾合并），成一个新的 Stream 流
    Stream<Integer> stream = Stream.concat(list_01.stream(), list_02.stream());
    stream.forEach(System.out::println);

3.3.9、比较：Optional max(Comparator<? super T> comparator) 根据Comparator比较器获取最大的元素

public static void main(String[] args) 
    // 将数组变成一个列表集合
    List<Integer> list = Arrays.asList(5, 3, 7, 9, 4);
    // 获取序列中的值最大的元素
    Optional<Integer> max = list.stream().max(Comparator.comparing((integer -> integer)));
    // 获取序列中的值最小的元素
    Optional<Integer> max = list.stream().min(Comparator.comparing((integer -> integer)));
    System.out.println(max.get());

3.3.10、分割：flatMap(T -> Stream) 将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流

@Test
public void name6() 
    List<String> list = new ArrayList<>();
    list.add("aaa bbb ccc");
    list.add("ddd eee fff");
    list.add("ggg hhh iii");

    list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());
    System.out.println(list);

//[aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii]

3.3.11、匹配: xxxMatch(T -> boolean)

//是否存在一个 person 对象的 age 等于 20：
boolean b = list.stream().anyMatch(person -> person.getAge() == 20);

//是否所有元素都匹配给定的 T -> boolean 条件
boolean result = list.stream().allMatch(Person::isStudent);

//是否没有元素匹配给定的 T -> boolean 条件
boolean result = list.stream().noneMatch(Person::isStudent);

3.3.12、查找：findAny() 和 findFirst()

• indAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream()并行时找到的是其中一个元素）
• findFirst()：找到第一个元素

值得注意的是，这两个方法返回的是一个 Optional 对象，它是一个容器类，能代表一个值存在或不存在。

3.3.13、归约：reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)

将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。在流中，reduce函数能实现归约。reduce函数接收两个参数：初始值和进行归约操作的Lambda表达式（用于组合流中的元素，如求和，求积，求最大值等）

int age = list.stream().reduce(0, (person1,person2)->person1.getAge()+person2.getAge());
//计算年龄总和：
int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);

//与之相同:其中，reduce 第一个参数 0 代表起始值为 0，lambda (a, b) -> a + b 即将两值相加产生一个新值
int sum = list.stream().map(Person::getAge).reduce(0, Integer::sum);

//计算年龄总乘积：
int sum = list.stream().map(Person::getAge).reduce(1, (a, b) -> a * b);

//当然也可以: 即不接受任何起始值，但因为没有初始值，需要考虑结果可能不存在的情况，因此返回的是 Optional 类型
Optional sum = list.stream().map(Person::getAge).reduce(Integer::sum);

3.4、采集置换：collect()

Stream采集功能分为List、map、group by、数组、求最大值、求任意值等

@Test
public void name5() 
    List<Integer> collect = appleStores.stream() // 获取appleStores的流
            .map(appleStore -> appleStore.getId()) // 转换功能：获取id，从List<AppleStore>转换成了List<int>
            .limit(3) // 取前三个元素
            .collect(Collectors.toList()); //将stream流转回List集合，依赖Collectors类中的几个toXxx()方法
    System.out.println(collect);

[1, 2, 3]