跳转至

深入理解 Java 中的 sum() 流操作

简介

在 Java 8 引入流（Stream）API 后，处理集合数据变得更加简洁和高效。sum() 是流操作中的一个非常实用的方法，它允许我们对数值流中的元素进行求和操作。本文将深入探讨 sum() 在 Java 流中的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一强大的功能。

目录

  1. 基础概念
  2. 使用方法
    • 基本类型流的使用
    • 对象流中使用 sum()
  3. 常见实践
    • 计算整数列表的总和
    • 计算对象属性的总和
  4. 最佳实践
    • 性能优化
    • 代码可读性与维护性
  5. 小结
  6. 参考资料

基础概念

在 Java 中，流是一种支持顺序和并行聚合操作的元素序列。sum() 方法专门用于数值流（如 IntStream、LongStream 和 DoubleStream），用于计算流中所有元素的总和。这些数值流是专门为处理基本数值类型而设计的，相比使用普通的 Stream<Integer> 等包装类型流，具有更好的性能和更简洁的语法。

使用方法

基本类型流的使用

  1. IntStream 示例
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("IntStream 元素的总和: " + sum);
    }
}

在这个示例中，我们首先创建了一个 IntStream，包含 1 到 5 的整数。然后调用 sum() 方法计算流中所有元素的总和，并将结果打印出来。

  1. LongStream 示例
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("LongStream 元素的总和: " + sum);
    }
}

LongStream 的使用方法与 IntStream 类似，只是处理的是 long 类型的数据。

  1. DoubleStream 示例
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("DoubleStream 元素的总和: " + sum);
    }
}

DoubleStream 用于处理 double 类型的流数据。

对象流中使用 sum()

当我们处理对象流时，需要先提取对象中的数值属性，然后再进行求和操作。例如，假设有一个 Person 类，包含 age 属性：

import java.util.ArrayList;
import java.util.List;

class Person {
    private int age;

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

    public int getAge() {
        return age;
    }
}

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

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

        System.out.println("所有人的年龄总和: " + totalAge);
    }
}

在这个示例中，我们首先创建了一个 Person 对象列表。然后通过 stream() 方法将列表转换为流，接着使用 mapToInt 方法提取每个 Person 对象的 age 属性，形成一个 IntStream，最后调用 sum() 方法计算年龄总和。

常见实践

计算整数列表的总和

在实际开发中，经常需要计算整数列表中所有元素的总和。可以使用流操作轻松实现：

import java.util.Arrays;
import java.util.List;

public class IntegerListSumExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
               .mapToInt(Integer::intValue)
               .sum();
        System.out.println("整数列表的总和: " + sum);
    }
}

这里我们将 List<Integer> 转换为 IntStream 后进行求和操作。

计算对象属性的总和

假设我们有一个包含多个商品对象的列表，每个商品对象有 price 属性，我们需要计算所有商品的总价：

import java.util.ArrayList;
import java.util.List;

class Product {
    private double price;

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

    public double getPrice() {
        return price;
    }
}

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

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

        System.out.println("所有商品的总价: " + totalPrice);
    }
}

通过将商品列表转换为流，提取 price 属性形成 DoubleStream，然后调用 sum() 方法计算总价。

最佳实践

性能优化

  1. 使用基本类型流：尽量使用 IntStream、LongStream 和 DoubleStream 等基本类型流，而不是包装类型流（如 Stream<Integer>）。基本类型流避免了自动装箱和拆箱的开销，提高了性能。
  2. 并行流的合理使用：对于大数据集，可以考虑使用并行流来提高计算速度。例如：
import java.util.Arrays;
import java.util.List;

public class ParallelStreamSumExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        int sum = numbers.parallelStream()
               .mapToInt(Integer::intValue)
               .sum();
        System.out.println("并行流计算的总和: " + sum);
    }
}

但要注意并行流在某些情况下可能会因为线程调度等开销而降低性能，需要根据具体情况进行测试和优化。

代码可读性与维护性

  1. 方法引用的使用：在提取对象属性时，尽量使用方法引用（如 Person::getAge），这样代码更加简洁和易读。
  2. 合理拆分操作：如果流操作链比较长，可以将其拆分成多个步骤，增加代码的可读性和可维护性。例如：
import java.util.ArrayList;
import java.util.List;

class Product {
    private double price;

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

    public double getPrice() {
        return price;
    }
}

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

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

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

        System.out.println("所有商品的总价: " + totalPrice);
    }
}

小结

sum() 方法在 Java 流中是一个非常实用的功能，它为我们处理数值求和提供了简洁高效的方式。通过了解基本概念、掌握使用方法、熟悉常见实践以及遵循最佳实践，我们可以在开发中更加灵活地运用 sum() 方法，提高代码的质量和性能。无论是处理简单的整数列表还是复杂的对象集合，Java 流的 sum() 方法都能帮助我们快速实现求和需求。

参考资料