Java函数式编程：toBeBetterJavaer Stream API-优快云博客

Java函数式编程：toBeBetterJavaer Stream API

【免费下载链接】toBeBetterJavaer JavaBooks：这是一个由多位资深Java开发者共同维护的Java学习资源库，内含大量高质量的Java教程、视频、博客等资料，可以帮助Java学习者快速提升技术水平。项目地址: https://gitcode.com/GitHub_Trending/to/toBeBetterJavaer

你还在为Java集合操作冗长的代码而烦恼吗？还在为处理数据时多层嵌套的循环而头疼吗？本文将带你深入探索Java 8引入的Stream API，通过函数式编程的方式简化数据处理流程，让代码更简洁、更易读、更高效。读完本文，你将掌握Stream API的创建、中间操作、终端操作以及与Lambda表达式的结合使用，轻松应对各种数据处理场景。

Stream API简介

Stream（流）是Java 8引入的一个全新概念，它与java.io包下的InputStream和OutputStream没有任何关系，而是用于处理集合的一种高级抽象。Stream API允许我们以声明式的方式处理数据，就像写SQL查询一样，通过一系列链式操作来筛选、转换和聚合数据。

Stream API的核心思想是将集合转换为一个流，然后对这个流进行一系列的中间操作，最后通过一个终端操作得到结果。中间操作会返回一个新的流，允许链式调用，而终端操作则会消费流并产生一个结果。

Stream API的主要优势包括：

简洁性：使用Lambda表达式和方法引用，大幅减少代码量
可读性：链式操作使得代码逻辑清晰，如同自然语言
高效性：内部优化（如惰性求值、短路操作）提高处理效率
并行性：无需编写复杂代码即可实现并行处理

相关概念可参考：Java 8 Stream流：掌握流式编程的精髓

Lambda表达式基础

在学习Stream API之前，我们需要先了解Lambda表达式，因为它是Stream API的基础。Lambda表达式是一种匿名函数，它允许我们将一段代码像数据一样传递。

Lambda表达式的基本语法如下：

(parameter-list) -> { expression-or-statements }

其中，parameter-list是参数列表，->是Lambda运算符，expression-or-statements是Lambda体。

例如，一个简单的Lambda表达式：

() -> System.out.println("Hello, Lambda!")

Lambda表达式可以用来简化匿名内部类的写法。比如，创建一个Runnable对象：

// 传统方式
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("传统方式创建Runnable");
    }
};

// Lambda方式
Runnable runnable2 = () -> System.out.println("Lambda方式创建Runnable");

更详细的Lambda表达式用法请参考：深入浅出Java 8 Lambda表达式

Stream的创建

要使用Stream API，首先需要创建一个流。创建流的方式有多种：

从集合创建

Collection接口在Java 8中添加了stream()方法，可以直接将集合转换为流：

List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> stream = list.stream();

此外，还可以通过parallelStream()方法创建并行流，用于并行处理：

Stream<String> parallelStream = list.parallelStream();

从数组创建

Arrays类提供了stream()方法，可以将数组转换为流：

String[] array = {"apple", "banana", "cherry"};
Stream<String> stream = Arrays.stream(array);

使用Stream.of()

Stream类的静态方法of()可以直接创建流：

Stream<String> stream = Stream.of("apple", "banana", "cherry");

创建无限流

Stream API还提供了创建无限流的方法，如iterate()和generate()：

// 生成从0开始的无限递增序列
Stream<Integer> infiniteStream1 = Stream.iterate(0, n -> n + 1);

// 生成随机数的无限流
Stream<Double> infiniteStream2 = Stream.generate(Math::random);

无限流通常需要配合limit()等操作来限制元素数量。

中间操作

中间操作是对数据流进行处理和转换的操作，它会返回一个新的流。常见的中间操作包括筛选、映射、排序、去重等。

筛选（filter）

filter()方法用于根据指定条件筛选元素，保留满足条件的元素：

List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date");
Stream<String> longFruits = fruits.stream()
                                 .filter(fruit -> fruit.length() > 5);

映射（map）

map()方法用于将流中的每个元素转换为另一种类型：

List<String> words = Arrays.asList("hello", "world");
Stream<Integer> wordLengths = words.stream()
                                  .map(String::length);

排序（sorted）

sorted()方法用于对流中的元素进行排序：

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Stream<Integer> sortedNumbers = numbers.stream()
                                      .sorted();

去重（distinct）

distinct()方法用于去除流中的重复元素：

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Stream<Integer> distinctNumbers = numbers.stream()
                                        .distinct();

其他中间操作

还有许多其他有用的中间操作，如：

limit(n)：限制流的大小为n个元素
skip(n)：跳过前n个元素
flatMap()：将每个元素转换为一个流，然后将所有流合并为一个流

终端操作

终端操作是流的最后一个操作，它会消费流并返回一个结果。常见的终端操作包括收集、聚合、遍历等。

收集（collect）

collect()方法用于将流中的元素收集到一个集合或其他数据结构中：

List<String> fruits = Arrays.asList("apple", "banana", "cherry");
List<String> upperCaseFruits = fruits.stream()
                                    .map(String::toUpperCase)
                                    .collect(Collectors.toList());

除了Collectors.toList()，还有Collectors.toSet()、Collectors.toMap()等方法，以及更复杂的收集操作。

聚合（reduce）

reduce()方法用于将流中的元素聚合为一个值：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream()
                              .reduce((a, b) -> a + b);

遍历（forEach）

forEach()方法用于遍历流中的元素：

List<String> fruits = Arrays.asList("apple", "banana", "cherry");
fruits.stream()
     .forEach(System.out::println);

匹配（anyMatch/allMatch/noneMatch）

这些方法用于检查流中的元素是否满足某些条件：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEven = numbers.stream()
                        .anyMatch(n -> n % 2 == 0); // 是否有偶数
boolean allPositive = numbers.stream()
                            .allMatch(n -> n > 0); // 是否所有元素都是正数
boolean noneNegative = numbers.stream()
                             .noneMatch(n -> n < 0); // 是否没有负数

计数（count）

count()方法用于统计流中元素的数量：

List<String> fruits = Arrays.asList("apple", "banana", "cherry");
long count = fruits.stream()
                  .count();

Stream API实战示例

下面通过几个实际例子来展示Stream API的强大功能。

示例1：筛选和排序

假设有一个字符串列表，我们需要筛选出长度大于5的字符串，并按字母顺序排序：

List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
List<String> result = words.stream()
                          .filter(word -> word.length() > 5)
                          .sorted()
                          .collect(Collectors.toList());
System.out.println(result); // [banana, cherry, elderberry]

示例2：数据转换和聚合

假设有一个员工列表，我们需要计算所有员工的平均工资：

class Employee {
    private String name;
    private double salary;
    
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    
    public double getSalary() {
        return salary;
    }
}

List<Employee> employees = Arrays.asList(
    new Employee("张三", 5000),
    new Employee("李四", 6000),
    new Employee("王五", 7000)
);

double averageSalary = employees.stream()
                               .mapToDouble(Employee::getSalary)
                               .average()
                               .orElse(0);
System.out.println(averageSalary); // 6000.0

示例3：分组和统计

假设有一个商品列表，我们需要按类别分组并统计每个类别的商品数量：

class Product {
    private String name;
    private String category;
    
    public Product(String name, String category) {
        this.name = name;
        this.category = category;
    }
    
    public String getCategory() {
        return category;
    }
}

List<Product> products = Arrays.asList(
    new Product("苹果", "水果"),
    new Product("香蕉", "水果"),
    new Product("西红柿", "蔬菜"),
    new Product("黄瓜", "蔬菜"),
    new Product("胡萝卜", "蔬菜")
);

Map<String, Long> categoryCount = products.stream()
                                         .collect(Collectors.groupingBy(
                                             Product::getCategory, 
                                             Collectors.counting()
                                         ));
System.out.println(categoryCount); // {水果=2, 蔬菜=3}

并行流

Stream API提供了简单的并行处理方式，只需将stream()改为parallelStream()即可：

List<Integer> numbers = IntStream.rangeClosed(1, 1000000).boxed().collect(Collectors.toList());

// 顺序流
long startTime = System.currentTimeMillis();
long sum1 = numbers.stream()
                  .reduce(0L, Long::sum);
long endTime = System.currentTimeMillis();
System.out.println("顺序流求和: " + sum1 + ", 耗时: " + (endTime - startTime) + "ms");

// 并行流
startTime = System.currentTimeMillis();
long sum2 = numbers.parallelStream()
                  .reduce(0L, Long::sum);
endTime = System.currentTimeMillis();
System.out.println("并行流求和: " + sum2 + ", 耗时: " + (endTime - startTime) + "ms");

需要注意的是，并行流并不总是比顺序流快，它适合处理大量数据且操作耗时的场景。此外，并行流使用的是公共的ForkJoinPool，可能会影响其他使用该池的任务。

Stream API注意事项

在使用Stream API时，需要注意以下几点：

流只能消费一次：一旦执行了终端操作，流就会被关闭，不能再使用。
惰性求值：中间操作不会立即执行，只有当终端操作执行时才会触发。
无状态：中间操作应该是无状态的，避免依赖外部状态。
副作用：尽量避免在Stream操作中产生副作用，如修改外部集合或变量。
空指针处理：注意处理可能的空指针异常，可以使用Optional类来避免。

总结

Stream API是Java 8引入的一个强大特性，它结合Lambda表达式，为我们提供了一种简洁、高效的数据处理方式。通过本文的学习，你应该已经掌握了Stream API的基本用法，包括流的创建、中间操作、终端操作以及与Lambda表达式的结合使用。

Stream API的主要优势在于它的简洁性和可读性，使得我们能够用更少的代码实现更复杂的数据处理逻辑。同时，它还提供了并行处理的能力，可以轻松利用多核处理器的优势。

要熟练掌握Stream API，需要不断实践和探索。建议你阅读官方文档和相关资料，如：

希望本文能够帮助你更好地理解和使用Stream API，让你的Java代码更加优雅和高效！

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考