Java Stream 中的 sum 操作：深入解析与实践

简介

在 Java 编程中，Stream API 是一个强大的工具，它为处理集合数据提供了一种简洁、高效且函数式的方式。其中的 sum 操作是 Stream API 众多有用功能之一，它允许我们快速地对数值类型的流进行求和计算。无论是处理简单的整数数组，还是复杂的对象集合中的数值字段，sum 操作都能帮助我们轻松完成求和任务。本文将深入探讨 Java Stream 中的 sum 操作，涵盖基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一功能。

目录

1. 基础概念
   • Stream 简介
   • sum 操作在 Stream 中的位置
2. 使用方法
   • 基本数值类型流的 sum 操作
   • 对象流中数值字段的 sum 操作
3. 常见实践
   • 数组求和
   • 集合中特定字段求和
4. 最佳实践
   • 性能优化
   • 代码可读性优化
5. 小结
6. 参考资料

基础概念

Stream 简介

Stream 是 Java 8 引入的一个新的抽象概念，它代表了一系列支持顺序和并行聚合操作的元素序列。Stream 并不存储数据，而是基于数据源（如集合、数组等）进行操作。它提供了一种函数式编程的方式来处理数据，使得代码更加简洁、易读和高效。

sum 操作在 Stream 中的位置

sum 操作是 Stream API 中的一个终端操作。终端操作会触发 Stream 的计算，返回一个结果或者副作用（如打印输出）。sum 操作专门用于对数值类型的 Stream 进行求和计算，适用于 IntStream、LongStream 和 DoubleStream 等基本数值类型的 Stream。

使用方法

基本数值类型流的 sum 操作

1. IntStream 的 sum 操作 ```java import java.util.stream.IntStream;

   public class IntStreamSumExample { public static void main(String[] args) { IntStream intStream = IntStream.of(1, 2, 3, 4, 5); int sum = intStream.sum(); System.out.println("Sum of integers: " + sum); } } `` 在上述代码中，我们首先创建了一个IntStream，包含了整数 1 到 5。然后通过调用sum` 方法，计算并输出了这些整数的和。

2. LongStream 的 sum 操作 ```java import java.util.stream.LongStream;

   public class LongStreamSumExample { public static void main(String[] args) { LongStream longStream = LongStream.of(1L, 2L, 3L, 4L, 5L); long sum = longStream.sum(); System.out.println("Sum of longs: " + sum); } } `` 这里创建了一个LongStream`，并对其中的长整型数据进行求和。

3. DoubleStream 的 sum 操作 ```java import java.util.stream.DoubleStream;

   public class DoubleStreamSumExample { public static void main(String[] args) { DoubleStream doubleStream = DoubleStream.of(1.5, 2.5, 3.5, 4.5, 5.5); double sum = doubleStream.sum(); System.out.println("Sum of doubles: " + sum); } } `` 此代码展示了如何对DoubleStream` 中的双精度浮点数进行求和。

对象流中数值字段的 sum 操作

假设我们有一个包含数值字段的对象类 Person，如下：

class Person {
    private int age;

    public Person(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

要对 Person 对象的集合中的 age 字段求和，可以这样做：

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

public class ObjectStreamSumExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person(25));
        people.add(new Person(30));
        people.add(new Person(35));

        int sumOfAges = people.stream()
              .mapToInt(Person::getAge)
              .sum();

        System.out.println("Sum of ages: " + sumOfAges);
    }
}

在这段代码中，我们首先创建了一个 Person 对象的列表。然后通过 stream 方法将列表转换为流，使用 mapToInt 方法将 Person 对象流转换为 IntStream，最后调用 sum 方法计算年龄的总和。

常见实践

数组求和

import java.util.Arrays;
import java.util.stream.IntStream;

public class ArraySumExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int sum = Arrays.stream(numbers).sum();
        System.out.println("Sum of array elements: " + sum);
    }
}

这里使用 Arrays.stream 方法将数组转换为 IntStream，然后直接调用 sum 方法求和。

集合中特定字段求和

假设我们有一个包含产品价格的 Product 类：

class Product {
    private double price;

    public Product(double price) {
        this.price = price;
    }

    public double getPrice() {
        return price;
    }
}

要计算产品列表中所有产品价格的总和：

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

public class ProductSumExample {
    public static void main(String[] args) {
        List<Product> products = new ArrayList<>();
        products.add(new Product(10.5));
        products.add(new Product(20.0));
        products.add(new Product(15.5));

        double totalPrice = products.stream()
              .mapToDouble(Product::getPrice)
              .sum();

        System.out.println("Total price of products: " + totalPrice);
    }
}

在这个例子中，我们将 Product 对象的列表转换为 DoubleStream，然后计算价格的总和。

最佳实践

性能优化

1. 并行流：对于大数据集，可以考虑使用并行流来提高 sum 操作的性能。例如： ```java import java.util.Arrays; import java.util.stream.IntStream;

   public class ParallelStreamSumExample { public static void main(String[] args) { int[] largeArray = new int[1000000]; for (int i = 0; i < largeArray.length; i++) { largeArray[i] = i + 1; }

       int sum = Arrays.stream(largeArray)
             .parallel()
             .sum();
   
       System.out.println("Sum using parallel stream: " + sum);
   }
   

   } ``` 并行流会利用多核处理器的优势，将数据分割成多个部分并行计算，从而加快求和速度。但需要注意的是，并行流在小数据集上可能会带来额外的开销，因此要根据实际情况选择是否使用。

2. 避免不必要的中间操作：尽量减少在流操作中使用不必要的中间操作，以免影响性能。例如，如果只需要求和，就不要进行排序等其他复杂操作。

代码可读性优化

1. 方法引用：使用方法引用可以使代码更加简洁和易读。如前面的例子中使用 Person::getAge 和 Product::getPrice 等方法引用，比使用匿名函数更加直观。
2. 合理拆分代码：如果流操作过于复杂，可以将其拆分成多个步骤，每个步骤使用有意义的变量名，这样可以提高代码的可读性和可维护性。例如：

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

public class ReadabilityExample {
    public static void main(String[] args) {
        List<Product> products = new ArrayList<>();
        products.add(new Product(10.5));
        products.add(new Product(20.0));
        products.add(new Product(15.5));

        // 提取价格流
        DoubleStream priceStream = products.stream()
              .mapToDouble(Product::getPrice);

        // 计算总和
        double totalPrice = priceStream.sum();

        System.out.println("Total price of products: " + totalPrice);
    }
}

小结

本文详细介绍了 Java Stream 中的 sum 操作，包括基础概念、使用方法、常见实践以及最佳实践。通过学习这些内容，读者可以在处理数值求和任务时更加得心应手，利用 Stream API 的强大功能写出简洁、高效且易读的代码。无论是处理基本数值类型的流，还是对象流中的数值字段求和，都可以根据具体情况选择合适的方法和技巧，以达到最佳的编程效果。

参考资料

• Oracle Java Documentation - Stream API
• Effective Java, Third Edition - Joshua Bloch