跳转至

Java Streams 示例：深入探索与实践

简介

在 Java 8 引入 Stream API 后，处理集合数据的方式发生了重大变革。Stream API 提供了一种更高效、简洁且声明式的方式来处理数据集合，无论是顺序处理还是并行处理。本文将通过丰富的示例深入探讨 Java Streams 的基础概念、使用方法、常见实践以及最佳实践，帮助读者全面掌握这一强大的特性。

目录

  1. 基础概念
    • 什么是 Java Streams
    • 流与集合的区别
  2. 使用方法
    • 创建流
    • 中间操作
    • 终端操作
  3. 常见实践
    • 过滤数据
    • 映射数据
    • 查找与匹配
    • 归约操作
  4. 最佳实践
    • 并行流的合理使用
    • 避免不必要的装箱和拆箱
    • 减少中间操作的开销
  5. 小结
  6. 参考资料

基础概念

什么是 Java Streams

Java Streams 是一系列支持顺序和并行聚合操作的元素序列。它提供了一种函数式编程的风格来处理数据集合，使得代码更加简洁和易读。流并不存储数据，而是基于数据源（如集合、数组等）进行操作。

流与集合的区别

  • 数据存储：集合是数据的存储结构，而流不存储数据，它只是对数据源的数据进行处理。
  • 遍历方式：集合需要显式的循环（如 for 循环）来遍历元素，而流通过声明式的操作来处理元素，无需显式的循环控制。
  • 处理时机：集合在创建时就存储了所有元素，而流的操作是按需计算的，只有在终端操作时才会触发实际的计算。

使用方法

创建流

  1. 从集合创建流 ```java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

    public class StreamExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); Stream streamFromList = numbers.stream(); streamFromList.forEach(System.out::println); } } 2. **从数组创建流**java import java.util.Arrays; import java.util.stream.Stream;

    public class StreamArrayExample { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; IntStream streamFromArray = Arrays.stream(numbers); streamFromArray.forEach(System.out::println); } } 3. **创建空流**java import java.util.stream.Stream;

    public class EmptyStreamExample { public static void main(String[] args) { Stream emptyStream = Stream.empty(); emptyStream.forEach(System.out::println); } } ```

中间操作

中间操作返回一个新的流，允许对数据进行一系列的转换。常见的中间操作包括 filter、map、sorted 等。

  1. 过滤数据 ```java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

    public class FilterExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); Stream filteredStream = numbers.stream() .filter(number -> number % 2 == 0); filteredStream.forEach(System.out::println); } } 2. **映射数据**java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

    public class MapExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); Stream mappedStream = numbers.stream() .map(number -> number * 2); mappedStream.forEach(System.out::println); } } 3. **排序**java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

    public class SortedExample { public static void main(String[] args) { List numbers = Arrays.asList(5, 2, 4, 1, 3); Stream sortedStream = numbers.stream() .sorted(); sortedStream.forEach(System.out::println); } } ```

终端操作

终端操作会触发流的计算，并返回一个结果或产生一个副作用（如打印输出）。常见的终端操作包括 forEach、collect、reduce 等。

  1. 遍历流元素 ```java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

    public class ForEachExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.stream() .forEach(System.out::println); } } 2. **收集流元素到集合**java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors;

    public class CollectExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); List evenNumbers = numbers.stream() .filter(number -> number % 2 == 0) .collect(Collectors.toList()); System.out.println(evenNumbers); } } 3. **归约操作**java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

    public class ReduceExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream() .reduce(0, (a, b) -> a + b); System.out.println(sum); } } ```

常见实践

过滤数据

在处理大量数据时，经常需要根据特定条件过滤出符合要求的数据。例如，从一个用户列表中过滤出年龄大于 18 岁的用户：

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

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class UserFilterExample {
    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(new User("Alice", 20));
        users.add(new User("Bob", 15));
        users.add(new User("Charlie", 25));

        List<User> adultUsers = users.stream()
              .filter(user -> user.getAge() > 18)
              .collect(Collectors.toList());
        adultUsers.forEach(user -> System.out.println(user.getAge()));
    }
}

映射数据

映射操作可以将一种类型的数据转换为另一种类型。比如，将一个字符串列表中的每个字符串转换为其长度：

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

public class StringLengthMapExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        List<Integer> lengths = words.stream()
              .map(String::length)
              .collect(Collectors.toList());
        System.out.println(lengths);
    }
}

查找与匹配

查找和匹配操作可以用于检查流中是否存在满足特定条件的元素。例如，检查一个数字列表中是否存在偶数：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class AnyMatchExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 3, 5, 7, 8);
        boolean hasEven = numbers.stream()
              .anyMatch(number -> number % 2 == 0);
        System.out.println(hasEven);
    }
}

归约操作

归约操作可以将流中的元素组合成一个值。例如，计算一个数字列表的乘积：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class ProductReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int product = numbers.stream()
              .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

最佳实践

并行流的合理使用

并行流可以利用多核处理器提高处理速度，但并非所有场景都适合使用并行流。在使用并行流时，需要考虑以下几点： - 数据量：对于小数据量，并行流的开销可能会超过其带来的性能提升。 - 操作复杂度：如果流的操作复杂度较低，并行流的优势也不明显。 - 数据独立性：并行流要求数据元素之间相互独立，否则可能会导致数据竞争和错误的结果。

避免不必要的装箱和拆箱

在处理基本数据类型时，尽量使用对应的原始流（如 IntStream、DoubleStream 等），避免自动装箱和拆箱带来的性能开销。

减少中间操作的开销

尽量减少不必要的中间操作，避免在流处理过程中创建过多的临时对象。可以通过合并多个中间操作来提高性能。

小结

本文通过丰富的示例深入探讨了 Java Streams 的基础概念、使用方法、常见实践以及最佳实践。Java Streams 为处理集合数据提供了一种强大而简洁的方式，通过合理运用流的操作，可以提高代码的可读性和性能。希望读者通过本文的学习，能够熟练掌握 Java Streams 并在实际项目中灵活应用。

参考资料