经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
Java Stream中的API你都用过了吗？
来源：cnblogs　　作者：架构成长指南　　时间：2023/11/22 16:45:53　　对本文有异议

公众号「架构成长指南」，专注于生产实践、云原生、分布式系统、大数据技术分享。

在本教程中，您将通过大量示例来学习 Java 8 Stream API。

Java 在 Java 8 中提供了一个新的附加包，称为 java.util.stream。该包由类、接口和枚举组成，允许对元素进行函数式操作。 您可以通过在程序中导入 java.util.stream包来使用流。

Stream提供以下功能：

Stream不存储元素。它只是通过计算操作的管道传送来自数据结构、数组或 I/O 通道等源的元素。

Stream本质上是函数式的，对流执行的操作不会修改其源。例如，过滤从集合获取的 Stream 会生成一个没有过滤元素的新 Stream，而不是从源集合中删除元素。

Stream是惰性的，仅在需要时才计算代码，在流的生命周期中，流的元素仅被访问一次。

与迭代器一样，必须生成新流才能重新访问源中的相同元素。
您可以使用 Stream 来 过滤、收集、打印以及 从一种数据结构转换为其他数据结构等。

Stream API 示例

1. 创建一个空的Stream

在创建空流时，应使用 empty() 方法：

  1. Stream<String> stream = Stream.empty();
  2. stream.forEach(System.out::println);

通常情况下，在创建时会使用 empty() 方法，以避免在没有元素的流中返回 null：

  1. public Stream<String> streamOf(List<String> list) {
  2.     return list == null || list.isEmpty() ? Stream.empty() : list.stream();
  3. }

2.从集合中创建流

  1. import java.io.IOException;
  2. import java.util.Arrays;
  3. import java.util.Collection;
  4. import java.util.HashSet;
  5. import java.util.List;
  6. import java.util.Set;
  7. import java.util.stream.Stream;
  9. public class StreamCreationExamples {
  10.     public static void main(String[] args) throws IOException {
  12.         Collection<String> collection = Arrays.asList("JAVA", "J2EE", "Spring", "Hibernate");
  13.         Stream<String> stream2 = collection.stream();
  14.         stream2.forEach(System.out::println);
  16.         List<String> list = Arrays.asList("JAVA", "J2EE", "Spring", "Hibernate");
  17.         Stream<String> stream3 = list.stream();
  18.         stream3.forEach(System.out::println);
  20.         Set<String> set = new HashSet<>(list);
  21.         Stream<String> stream4 = set.stream();
  22.         stream4.forEach(System.out::println);
  23.     }
  24. }

输出

  1. JAVA
  2. J2EE
  3. Spring
  4. Hibernate
  5. JAVA
  6. J2EE
  7. Spring
  8. Hibernate
  9. JAVA
  10. Hibernate
  11. J2EE
  12. Spring

3. 从数组中创建流对象

数组可以是流的源，也可以从现有数组或数组的一部分创建数组：

  1. import java.util.Arrays;
  2. import java.util.stream.Stream;
  4. public class StreamCreationExample {
  5.     public static void main(String[] args) {
  6.         // 使用Arrays.stream()创建流
  7.         int[] numbers = {1, 2, 3, 4, 5};
  8.         Stream<Integer> stream1 = Arrays.stream(numbers);
  9.         System.out.println("Using Arrays.stream():");
  10.         stream1.forEach(System.out::println);
  12.         // 使用Stream.of()创建流
  13.         String[] names = {"Alice", "Bob", "Charlie"};
  14.         Stream<String> stream2 = Stream.of(names);
  15.         System.out.println("Using Stream.of():");
  16.         stream2.forEach(System.out::println);
  18.         // 使用Stream.builder()创建流
  19.         String[] colors = {"Red", "Green", "Blue"};
  20.         Stream.Builder<String> builder = Stream.builder();
  21.         for (String color : colors) {
  22.             builder.add(color);
  23.         }
  24.         Stream<String> stream3 = builder.build();
  25.         System.out.println("Using Stream.builder():");
  26.         stream3.forEach(System.out::println);
  27.     }
  28. }

输出

  1. Using Arrays.stream():
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. Using Stream.of():
  8. Alice
  9. Bob
  10. Charlie
  11. Using Stream.builder():
  12. Red
  13. Green
  14. Blue

4. 使用Stream过滤一个集合示例

在下面的示例中，我们不使用流过滤数据，看看代码是什么样的，同时我们在给出一个使用stream过滤的示例，对比一下

不使用Stream过滤一个集合示例

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class FilterWithoutStreamExample {
  5.     public static void main(String[] args) {
  6.         List<Integer> numbers = new ArrayList<>();
  7.         numbers.add(10);
  8.         numbers.add(20);
  9.         numbers.add(30);
  10.         numbers.add(40);
  11.         numbers.add(50);
  13.         List<Integer> filteredNumbers = new ArrayList<>();
  14.         for (Integer number : numbers) {
  15.             if (number > 30) {
  16.                 filteredNumbers.add(number);
  17.             }
  18.         }
  20.         System.out.println("Filtered numbers (without Stream):");
  21.         for (Integer number : filteredNumbers) {
  22.             System.out.println(number);
  23.         }
  24.     }
  25. }

输出：

  1. Filtered numbers (without Stream):
  2. 40
  3. 50

使用 Stream 过滤集合示例：

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class FilterWithStreamExample {
  5.     public static void main(String[] args) {
  6.         List<Integer> numbers = new ArrayList<>();
  7.         numbers.add(10);
  8.         numbers.add(20);
  9.         numbers.add(30);
  10.         numbers.add(40);
  11.         numbers.add(50);
  13.         List<Integer> filteredNumbers = numbers.stream()
  14.                 .filter(number -> number > 30)
  15.                 .toList();
  17.         System.out.println("Filtered numbers (with Stream):");
  18.         filteredNumbers.forEach(System.out::println);
  19.     }
  20. }

输出：

  1. Filtered numbers (with Stream):
  2. 40
  3. 50

前后我们对比一下，可以看到，使用 Stream 进行集合过滤可以更加简洁和直观，减少了手动迭代和添加元素的步骤。它提供了一种声明式的编程风格，使代码更易读、可维护和可扩展。

5. 使用Stream过滤和遍历集合

在下面的示例中，我们使用 filter() 方法进行过滤，使用 forEach() 方法对数据流进行迭代：

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class FilterAndIterateWithStreamExample {
  5.     public static void main(String[] args) {
  6.         List<String> names = new ArrayList<>();
  7.         names.add("Alice");
  8.         names.add("Bob");
  9.         names.add("Charlie");
  10.         names.add("David");
  11.         names.add("Eve");
  13.         System.out.println("Filtered names starting with 'A':");
  14.         names.stream()
  15.                 .filter(name -> name.startsWith("A"))
  16.                 .forEach(System.out::println);
  17.     }
  18. }

输出

  1. Filtered names starting with 'A':
  2. Alice

在上述示例中，我们有一个字符串列表 names，其中包含了一些名字。
我们使用 Stream 进行过滤和迭代操作以查找以字母 "A" 开头的名字。

6.使用Collectors方法求和

我们还可以使用Collectors计算数值之和。

在下面的示例中，我们使用Collectors类及其指定方法计算所有产品价格的总和。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.stream.Collectors;
  5. public class SumByUsingCollectorsMethods {
  6.     public static void main(String[] args) {
  7.         List < Product > productsList = new ArrayList < Product > ();
  8.         productsList.add(new Product(1, "HP Laptop", 25000f));
  9.         productsList.add(new Product(2, "Dell Laptop", 30000f));
  10.         productsList.add(new Product(3, "Lenevo Laptop", 28000f));
  11.         productsList.add(new Product(4, "Sony Laptop", 28000f));
  12.         productsList.add(new Product(5, "Apple Laptop", 90000f));
  13.         
  14.         double totalPrice3 = productsList.stream()
  15.             .collect(Collectors.summingDouble(product -> product.getPrice()));
  16.         System.out.println(totalPrice3);
  18.     }
  19. }

输出

  1. 201000.0

7. 使用Stream查找年龄最大和最小的学生

假设有一个 Student 类具有 name 和 age 属性。我们可以使用 Stream 来查找学生集合中年龄的最大和最小值，并打印出相应的学生信息。以下是一个示例：

  1. import java.util.ArrayList;
  2. import java.util.Comparator;
  3. import java.util.List;
  4. import java.util.Optional;
  6. public class StudentStreamExample {
  7.     public static void main(String[] args) {
  8.         List<Student> students = new ArrayList<>();
  9.         students.add(new Student("Alice", 20));
  10.         students.add(new Student("Bob", 22));
  11.         students.add(new Student("Charlie", 19));
  12.         students.add(new Student("David", 21));
  14.         // 查找年龄最大的学生
  15.         Optional<Student> maxAgeStudent = students.stream()
  16.                 .max(Comparator.comparingInt(Student::getAge));
  18.         // 查找年龄最小的学生
  19.         Optional<Student> minAgeStudent = students.stream()
  20.                 .min(Comparator.comparingInt(Student::getAge));
  22.         // 打印最大和最小年龄的学生信息
  23.         System.out.println("Student with maximum age:");
  24.         maxAgeStudent.ifPresent(System.out::println);
  26.         System.out.println("Student with minimum age:");
  27.         minAgeStudent.ifPresent(System.out::println);
  28.     }
  29. }
  31. class Student {
  32.     private String name;
  33.     private int age;
  35.     public Student(String name, int age) {
  36.         this.name = name;
  37.         this.age = age;
  38.     }
  40.     public String getName() {
  41.         return name;
  42.     }
  44.     public int getAge() {
  45.         return age;
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Student{" +
  51.                 "name='" + name + '\'' +
  52.                 ", age=" + age +
  53.                 '}';
  54.     }
  55. }

输出：

  1. Student with maximum age:
  2. Student{name='Bob', age=22}
  3. Student with minimum age:
  4. Student{name='Charlie', age=19}

8. 使用Stream转换List为Map

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Map;
  4. import java.util.stream.Collectors;
  6. public class StudentStreamToMapExample {
  7.     public static void main(String[] args) {
  8.         List<Student> students = new ArrayList<>();
  9.         students.add(new Student("Alice", 20));
  10.         students.add(new Student("Bob", 22));
  11.         students.add(new Student("Charlie", 19));
  12.         students.add(new Student("David", 21));
  14.         // 将学生列表转换为 Map，以姓名为键，学生对象为值
  15.         Map<String, Student> studentMap = students.stream()
  16.                 .collect(Collectors.toMap(Student::getName, student -> student));
  18.         // 打印学生 Map
  19.         for (Map.Entry<String, Student> entry : studentMap.entrySet()) {
  20.             System.out.println(entry.getKey() + ": " + entry.getValue());
  21.         }
  22.     }
  23. }
  25. class Student {
  26.     private String name;
  27.     private int age;
  29.     public Student(String name, int age) {
  30.         this.name = name;
  31.         this.age = age;
  32.     }
  34.     public String getName() {
  35.         return name;
  36.     }
  38.     public int getAge() {
  39.         return age;
  40.     }
  42.     @Override
  43.     public String toString() {
  44.         return "Student{" +
  45.                 "name='" + name + '\'' +
  46.                 ", age=" + age +
  47.                 '}';
  48.     }
  49. }

输出

  1. David: Student{name='David', age=21}
  2. Bob: Student{name='Bob', age=22}
  3. Charlie: Student{name='Charlie', age=19}
  4. Alice: Student{name='Alice', age=20}

在上面示例中，我们使用Collectors.toMap() 方法将学生列表转换为 Map。我们指定了键提取器 Student::getName，将学生的姓名作为键。对于值提取器，我们使用了一个匿名函数 student -> student，它返回学生对象本身作为值。

9. 使用Stream把List对象转换为另一个List对象

假设我们有一个 Person 类，其中包含姓名和年龄属性。我们可以使用 Stream 来将一个 List 对象转换为另一个 List 对象，其中只包含人员的姓名。以下是一个示例：

  1.   import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.stream.Collectors;
  5. public class ListTransformationExample {
  6.     public static void main(String[] args) {
  7.         List<Person> persons = new ArrayList<>();
  8.         persons.add(new Person("Alice", 20));
  9.         persons.add(new Person("Bob", 22));
  10.         persons.add(new Person("Charlie", 19));
  12.         // 将 Person 列表转换为只包含姓名的 String 列表
  13.         List<String> names = persons.stream()
  14.                 .map(Person::getName)
  15.                 .collect(Collectors.toList());
  17.         // 打印转换后的姓名列表
  18.         System.out.println(names);
  19.     }
  20. }
  22. class Person {
  23.     private String name;
  24.     private int age;
  26.     public Person(String name, int age) {
  27.         this.name = name;
  28.         this.age = age;
  29.     }
  31.     public String getName() {
  32.         return name;
  33.     }
  35.     public int getAge() {
  36.         return age;
  37.     }
  38. }

输出：

  1.   [Alice, Bob, Charlie]

在上述示例中，我们有一个 Person 类，其中包含姓名和年龄属性。我们创建了一个 persons 列表，并添加了几个 Person 对象。

使用Stream，我们通过调用 map() 方法并传入一个方法引用 Person::getName，最后，我们使用 collect() 方法和 Collectors.toList() 将转换后的姓名收集到一个新的列表中。

API

https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

原文链接：https://www.cnblogs.com/waldron/p/17848756.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号