【Java 8】手把手教你 Stream 类

阳光穿透心脏的1/2处 2023-10-03 16:14 2阅读 0赞

### 1. Stream 概述 ###

Stream 是 Java8 中处理集合的关键抽象概念（将要处理的集合元素看作一种流），它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

总之，Stream API 提供了一种高效且易于使用的处理数据的方式。

它的特点：

*  它不是数据结构，所以，不会保存数据，只是按照特定的规则对数据进行计算，一般会输出结果
 *  不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中（保留意见：毕竟peek方法可以修改流中元素）
 *  惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算

Stream 对流的操作分为两种：中间操作、终端操作

*  中间操作：每次返回一个新的流，可以进行多次操作
 *  终端操作：每个流只能进行一次终端操作，终端操作结束后，流无法再次使用。终端操作会产生一个新的集合或值

![在这里插入图片描述][3e18bb27fbfc4fb49c45e900e0a8e7ae.png]

*  无状态：指元素的处理不受之前元素的影响
 *  有状态：指该操作只有拿到所有元素之后才能继续下去
 *  非短路操作：指必须处理所有元素才能得到最终结果
 *  短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果

在使用 stream 之前，先理解一个概念：Optional。因为 Stream 中的元素是以 Optional 类型存在的。

### 2. Stream 用法 ###

#### 2.1 创建 Stream ####

**1、通过 `java.util.Collection.stream()` 方法用集合创建流**

public static void main(String[] args) {
        
        List<String> list = Arrays.asList("a", "b", "c");
        // 顺序流
        Stream<String> stream = list.stream();
        // 并行流
        Stream<String> stringStream = list.parallelStream();
    }

stream 和 stringStream 的简单区分： stream 是顺序流，由主线程按顺序对流执行操作；而stringStream 是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求

如果流中的数据量足够大，并行流可以加快处速度。除了直接创建并行流，还可以通过 `parallel()` 方法把顺序流转换成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x-> x > 6).findFirst();

**2、使用 `java.util.Arrays.stream(T[] array)` 方法用数组创建流**

int[] array = {
        1, 2, 3, 4, 5};
    IntStream stream1 = Arrays.stream(array);

**3、使用Stream的静态方法：`of()`、`iterate()`、`generate()`**

// 1. of()
    Stream<Integer> integerStream = Stream.of(10, 20, 30);
    
    // 2. iterate() 通过迭代方法，生成一个有序无限的数据流。（由于是无限流，一般都是配合 limit() 方法来使用）
    Stream<Integer> integerStream1 = Stream.iterate(2, x -> x + 2).limit(5);
    integerStream1.forEach(System.out::println);
    
    // 3. generate() 返回无限顺序无序流
    Stream<Double> doubleStream = Stream.generate(Math::random).limit(3);
    doubleStream.forEach(System.out::println);
    
    Stream.generate(new Random()::nextInt).limit(3).forEach(System.out::println);

#### 2.2 流的操作 ####

后续需要使用的实体类

public class User {
        
        private String name;
        private int salary;
        private int age;
        private String sex;
        private String area;
    	
    	// getter/setter
    }

public class UserUtil {
        
    
        public static List<User> userList = null;
    
        static {
        
            userList = new ArrayList<>();
            userList.add(new User("Tom", 8900, "male", "New York"));
            userList.add(new User("Jack", 7000, "male", "Washington"));
            userList.add(new User("Lily", 7800, "female", "Washington"));
            userList.add(new User("Anni", 8200, "female", "New York"));
            userList.add(new User("Owen", 9500, "male", "New York"));
            userList.add(new User("Alisa", 7900, "female", "New York"));
        }
    
        private UserUtil() {
        }
    
        public static List<User> getUserList() {
        
            return userList;
        }
    }

##### 2.2.1 filter()/forEach 过滤/遍历 #####

1、遍历输出集合中大于 3 的值

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    // 遍历输出符合条件的值
    integerList.stream().filter(x -> x > 3).forEach(System.out::println);

2、将原集合大于 3 的元素赋值到新的集合中去

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    // 返回一个符合条件的新集合
    List<Integer> collect = integerList.stream().filter(x -> x > 3)
    											.collect(Collectors.toList());

##### 2.2.2 find() 查找 #####

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    
    // 1. 输出符合条件的第一个元素的值
    Optional<Integer> first = integerList.stream().filter(x -> x > 3).findFirst();
    System.out.println(first.get());
    // 2. 输出符合条件的任何元素的值 findAny 适用于并行流
    Optional<Integer> any = integerList.parallelStream().filter(x -> x > 3).findAny();
    System.out.println(any.get());
    // 3. 是否包含特定条件的元素
    boolean b = integerList.stream().anyMatch(x -> x > 10);
    System.out.println(b);

##### 2.2.3 max() 最大值 #####

1、获取字符串最长的对象

List<String> stringList = Arrays.asList("C++", "Java", "Go", "Python");
    Optional<String> max = stringList.stream().max(Comparator.comparing(String::length));
    System.out.println(max.get());

2、获取 Integer 集合中最大值的元素

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    // 1. 获取最大值---自然排序
    Optional<Integer> max1 = integerList.stream().max(Integer::compareTo);
    System.out.println(max1.get());
    
    // 2. 获取最大值---自定义排序
    Optional<Integer> max2 = integerList.stream().max(new Comparator<Integer>() {
        
        @Override
        public int compare(Integer o1, Integer o2) {
        
            return o1.compareTo(o2);
        }
    });
    System.out.println(max2.get());

3、获取员工工资最高的人

List<User> userList = UserUtil.getUserList();
    Optional<User> max3 = userList.stream().max(Comparator.comparingInt(User::getSalary));
    System.out.println(max3.get());

##### 2.2.4 count() 计数 #####

计算 Integer 集合中大于6的元素的个数

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    // 获取符合特定条件的元素个数
    long count = integerList.stream().filter(x -> x > 3).count();
    System.out.println(count);

##### 2.2.5 map() 映射 #####

1、英文集合中的元素全部变为大写

List<String> stringList = Arrays.asList("C++", "Java", "Go", "Python");
    List<String> collect1 = stringList.stream().map(String::toUpperCase).collect(Collectors.toList());

2、整数集合中的元素都加 3

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    List<Integer> collect2 = integerList.stream().map(x -> x + 3).collect(Collectors.toList());

3、将员工的薪资加 1000

List<User> userList2 = UserUtil.getUserList();
    // 1. 不改变原来的集合
    List<User> userListNew = userList2.stream().map(user -> {
        
        User u = new User();
        u.setName(user.getName());
        u.setSalary(user.getSalary() + 1000);
        return u;
    }).collect(Collectors.toList());
    
    // 2. 改变原来的集合
    List<User> userList3 = UserUtil.getUserList();
    List<User> userListNew2 = userList3.stream().map(user -> {
        
        user.setSalary(user.getSalary() + 1000);
        return user;
    }).collect(Collectors.toList());

##### 2.2.6 reduce() 归约 #####

归约，也称缩减，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作

1、求 Integer 集合的元素之和

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    // 方式一
    Optional<Integer> reduce = integerList.stream().reduce((x, y) -> x + y);
    System.out.println(reduce.get());
    
    // 方式二
    Optional<Integer> reduce1 = integerList.stream().reduce(Integer::sum);
    System.out.println(reduce1.get());
    
    // 方式三
    Integer reduce2 = integerList.stream().reduce(0, Integer::sum);
    System.out.println(reduce2);

2、求 Integer 集合的元素之积

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    Optional<Integer> reduce3 = integerList.stream().reduce((x, y) -> x * y);

3、求 Integer 集合的最大值

List<Integer> integerList = Arrays.asList(1, 3, 5, 6, 9);
    // 方式一
    Optional<Integer> reduce4 = integerList.stream().reduce((x, y) -> x > y ? x : y);
    System.out.println(reduce4.get());
    
    // 方式二
    Integer reduce5 = integerList.stream().reduce(0, Integer::max);
    System.out.println(reduce5);

4、求所有员工的工资之和

// 方式一
    List<User> userList4 = UserUtil.getUserList();
    Optional<Integer> reduce6 = userList4.stream().map(User::getSalary).reduce(Integer::sum);
    System.out.println(reduce6.get());
    
    // 方式二
    Integer reduce8 = userList4.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
    System.out.println(reduce8);
    
    // 方式三
    userList4.stream().reduce(0, (sum, p) -> sum += p.getSalary(), (sum1, sum2) -> sum1 + sum2);

5、求所有员工的最高工资

List<User> userList5 = UserUtil.getUserList();
    Integer reduce7 = userList5.stream().reduce(0, (m, p) -> m > p.getSalary() ? m : p.getSalary(), Integer::max);
    System.out.println(reduce7);

##### 2.2.7 collect() 收集 #####

collect()，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。

collect() 主要依赖 `java.util.stream.Collectors` 类内置的静态方法。

###### 2.2.7.1 toList()/toSet()/toMap() 归集 ######

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet 和 toMap 比较常用，另外还有 toCollection、toConcurrentMap 等复杂一些的用法。

// toList()
    List<Integer> integerList = Arrays.asList(1, 3, 4, 6, 8, 9, 12);
    List<Integer> collect = integerList.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
    System.out.println(collect);
    
    // toSet()
    Set<Integer> collect2 = integerList.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
    System.out.println(collect);
    
    // toMap()
    List<User> userList = UserUtil.getUserList();
    Map<String, User> collect3 = userList.stream().filter(user -> user.getSalary() > 8000).collect(Collectors.toMap(User::getName, user -> user));
    System.out.println(collect3);

###### 2.2.7.2 count()/averaging() 计数/平均 ######

Collectors 提供了一系列用于数据统计的静态方法：

*  计数：count()
 *  平均值：averagingInt()、averagingLong()、averagingDouble()
 *  最值：maxBy()、minBy()
 *  求和：summingInt()、summingLong()、summingDouble()
 *  统计以上所有：summarizingInt()、summarizingLong()、summarizingDouble()

1、统计员工集合的人数

// 方式一
    long count = userList.stream().count();
    System.out.println(count);
    
    // 方式二
    long count2 = userList.stream().collect(Collectors.counting());

2、员工集合的平均工资

Double collect1 = userList.stream().collect(Collectors.averagingDouble(User::getSalary));
    System.out.println(collect1);

3、员工集合的最高工资

Optional<Integer> collect4 = userList.stream().map(User::getSalary).collect(Collectors.maxBy(Integer::compare));
    System.out.println(collect4.get());

4、员工的工资总和

Integer collect5 = userList.stream().collect(Collectors.summingInt(User::getSalary));
    System.out.println(collect5);

5、统计所有信息（总数、合计、最小值、平均值、最大值）

DoubleSummaryStatistics collect6 = userList.stream().collect(Collectors.summarizingDouble(User::getSalary));
    System.out.println(collect6);

##### 2.2.8 partitioningBy()/groupingBy() 分组 #####

*  分区：将 Stream 按条件分为两个 Map，比如员工按薪资是否高于8000分为两部分。
 *  分组：将集合分为多个 Map，比如员工按性别分组。有单级分组和多级分组

1、将员工按薪资是否高于8000分为两部分

Map<Boolean, List<User>> collect7 = userList.stream().collect(Collectors.partitioningBy(user -> user.getSalary() > 8000));
    System.out.println(collect7);
    
    // groupingBy() 分组
    Map<String, List<User>> collect8 = userList.stream().collect(Collectors.groupingBy(User::getSex));
    System.out.println(collect8);

2、将员工按性别和地区分组

// groupingBy() 多级分组 先按性别分组，再按地区分组
    Map<String, Map<String, List<User>>> collect9 =
            userList.stream().collect(Collectors.groupingBy(User::getSex, Collectors.groupingBy(User::getArea)));
    System.out.println(collect9);

##### 2.2.8 joining() 接合 #####

joining() 可以将 Stream 中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串

List<String> strings = Arrays.asList("A", "B", "C");
    String collect10 = strings.stream().collect(Collectors.joining("-"));
    System.out.println(collect10);
    
    String collect11 = userList.stream().map(user -> user.getName()).collect(Collectors.joining(","));
    System.out.println(collect11);

##### 2.2.9 sorted() 排序 #####

sorted()，中间操作。有两种排序：

*  sorted()：自然排序，流中元素需实现Comparable接口
 *  sorted(Comparator com)：Comparator 排序器自定义排序

1、将员工按工资由低到高排序（自然排序）

List<String> collect13 = userList.stream().sorted(Comparator.comparing(User::getSalary)).map(User::getName).collect(Collectors.toList());
    System.out.println(collect13);

2、将员工按工资由高到低排序（reversed() 方法）

List<String> collect14 = userList.stream().sorted(Comparator.comparing(User::getSalary).reversed())
    								.map(User::getName).collect(Collectors.toList());
    System.out.println(collect13);

3、先按工资、再按年龄升序排序（thenComparing() 方法）

// 自然排序
    List<User> collect15 = userList.stream().sorted(Comparator.comparing(User::getSalary).thenComparing(User::getAge)).collect(Collectors.toList());
    System.out.println(collect15);
    
    // 自定义排序
    userList.stream().sorted((user1, user2) -> {
        
        if (user1.getSalary() == user2.getSalary()) {
        
            return user1.getAge() - user2.getAge();
        } else {
        
            return user2.getSalary() - user1.getSalary();
        }
    }).collect(Collectors.toList());

##### 2.2.10 提取/组合 #####

流也可以进行合并、去重、限制、跳过等操作

String[] arr1 = {
        "a", "b", "c", "d", "e"};
    String[] arr2 = {
        "f", "g", "h", "i", "g"};
    
    // concat:合并两个流 distinct：去重
    List<String> list = Stream.concat(Stream.of(arr1), Stream.of(arr2)).distinct().collect(Collectors.toList());
    
    // limit：限制从流中获得前n个数据
    List<Integer> integers = Stream.iterate(1, x -> x + 2).limit(5).collect(Collectors.toList());
    
    // // skip：跳过前n个数据
    List<Integer> integerList2 = Stream.iterate(1, x -> x + 2).skip(2).limit(5).collect(Collectors.toList());

[3e18bb27fbfc4fb49c45e900e0a8e7ae.png]: https://img-blog.csdnimg.cn/3e18bb27fbfc4fb49c45e900e0a8e7ae.png