JavaStream生成等间隔时间序列技巧

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个文章开发实战，手把手教大家学习《Java Stream生成等间隔时间序列方法》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

本文详细介绍了如何利用Java 8及更高版本提供的`Stream.iterate`方法结合`java.time` API来高效生成一系列等间隔的时间序列数据。教程涵盖了从创建无限流到通过`limit`或`takeWhile`控制流长度，再到将结果收集为列表并使用`DateTimeFormatter`进行格式化的完整过程，并提供了具体代码示例。

1. 核心概念：Stream.iterate

Stream.iterate是Java Stream API中一个强大的静态方法，专为生成序列化元素而设计。它接受一个初始值（种子）和一个UnaryOperator函数，该函数应用于前一个元素以生成下一个元素。其基本形式为：

Stream.iterate(T seed, UnaryOperator f)

这个方法会生成一个无限流，其中第一个元素是seed，第二个是f.apply(seed)，第三个是f.apply(f.apply(seed))，以此类推。

对于Java 9及更高版本，还提供了另一个重载形式，允许在生成过程中加入一个谓词来控制流的终止：

Stream.iterate(T seed, Predicate hasNext, UnaryOperator next)

2. 生成等间隔时间序列

在Java中处理日期和时间，强烈推荐使用java.time包（JSR 310），它提供了不可变、线程安全的日期时间对象。结合Stream.iterate，可以优雅地生成等间隔的时间序列。

2.1 基础构建块：LocalTime 和 Duration

• LocalTime: 表示不带日期或时区的时间（例如，10:30:00）。
• Duration: 表示时间量或持续时间，例如2秒、5分钟、1小时。

Duration类提供了一个addTo(Temporal temporal)方法，可以将此持续时间添加到给定的Temporal对象（如LocalTime、LocalDateTime等），并返回一个新的Temporal对象。这正是Stream.iterate所需的UnaryOperator。

示例：创建无限时间流

假设我们想从10:05:00开始，每隔5分钟生成一个时间点：

import java.time.LocalTime;
import java.time.Duration;
import java.util.stream.Stream;

// 从 10:05 开始，每隔 5 分钟递增
Stream timeStream = Stream.iterate(
    LocalTime.of(10, 5), // 种子：开始时间
    Duration.ofMinutes(5)::addTo // UnaryOperator：每次增加 5 分钟
);

// 注意：这是一个无限流，直接打印会持续运行
// timeStream.forEach(System.out::println); // 实际应用中不应直接运行此行

3. 控制流的长度与终止

由于Stream.iterate默认生成无限流，我们需要方法来限制其长度，以避免资源耗尽。

3.1 使用 Stream.limit() 限制数量

limit(long maxSize)方法可以截断流，使其包含不超过指定数量的元素。

import java.time.LocalTime;
import java.time.Duration;
import java.util.List;
import java.util.stream.Collectors;

// 生成从 10:00:00 开始，每隔 2 秒递增的 100 个时间点
List timesBySeconds = Stream.iterate(
        LocalTime.of(10, 0, 0),
        Duration.ofSeconds(2)::addTo
    )
    .limit(100) // 限制为 100 个元素
    .collect(Collectors.toList());

// timesBySeconds.forEach(System.out::println);

3.2 使用 Stream.takeWhile() 基于条件终止 (Java 9+)

takeWhile(Predicate predicate)方法会从流中获取元素，直到谓词返回false。一旦谓词返回false，流就会终止。

import java.time.LocalTime;
import java.time.Duration;
import java.util.List;
import java.util.stream.Collectors;

// 生成从 10:00:00 开始，每隔 5 分钟递增，直到不晚于 12:00:00 的时间点
List timesUntilNoon = Stream.iterate(
        LocalTime.of(10, 0, 0),
        Duration.ofMinutes(5)::addTo
    )
    .takeWhile(time -> !time.isAfter(LocalTime.of(12, 0, 0))) // 只要时间不晚于 12:00
    .collect(Collectors.toList());

// timesUntilNoon.forEach(System.out::println);

对于Java 8用户，如果需要基于条件终止，可以考虑使用Stream.iterate(seed, f).filter(predicate).limit(maxSize)的组合，或者手动构建循环。但takeWhile在语义上更清晰。

4. 收集结果并格式化输出

生成LocalTime对象列表后，通常需要将其转换为特定的字符串格式。

4.1 收集到 List

使用Stream.toList()（Java 16+）或Collectors.toList()（Java 8+）将流中的元素收集到一个List中。

// ... (前面生成流的代码)
List timeList = timeStream.limit(someCount).toList(); // 推荐 Java 16+
// 或者
List timeList = timeStream.limit(someCount).collect(Collectors.toList()); // 兼容 Java 8+

4.2 使用 DateTimeFormatter 格式化

java.time.format.DateTimeFormatter类用于格式化和解析日期时间对象。可以通过ofPattern定义自定义格式，或使用预定义的格式（如ISO_LOCAL_TIME）。

import java.time.LocalTime;
import java.time.Duration;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TimeSeriesGenerator {

    /**
     * 生成从指定开始时间起，每隔指定秒数递增的序列，共 count 个元素。
     *
     * @param startTimeStr 开始时间字符串，例如 "10:00:00"
     * @param intervalSeconds 间隔秒数
     * @param count 元素数量
     * @return 格式化后的时间字符串列表
     */
    public static List bySeconds(String startTimeStr, int intervalSeconds, int count) {
        LocalTime startTime = LocalTime.parse(startTimeStr);
        return Stream.iterate(startTime, Duration.ofSeconds(intervalSeconds)::addTo)
                .limit(count)
                .map(DateTimeFormatter.ISO_LOCAL_TIME::format) // 格式化为 "HH:mm:ss"
                .collect(Collectors.toList());
    }

    /**
     * 生成从指定开始时间起，每隔指定分钟数递增的序列，共 count 个元素。
     *
     * @param startTimeStr 开始时间字符串，例如 "10:00:00"
     * @param intervalMinutes 间隔分钟数
     * @param count 元素数量
     * @return 格式化后的时间字符串列表
     */
    public static List byMinutes(String startTimeStr, int intervalMinutes, int count) {
        LocalTime startTime = LocalTime.parse(startTimeStr);
        return Stream.iterate(startTime, Duration.ofMinutes(intervalMinutes)::addTo)
                .limit(count)
                .map(DateTimeFormatter.ISO_LOCAL_TIME::format)
                .collect(Collectors.toList());
    }

    /**
     * 生成从指定开始时间起，每隔指定小时数递增的序列，共 count 个元素。
     *
     * @param startTimeStr 开始时间字符串，例如 "10:00:00"
     * @param intervalHours 间隔小时数
     * @param count 元素数量
     * @return 格式化后的时间字符串列表
     */
    public static List byHours(String startTimeStr, int intervalHours, int count) {
        LocalTime startTime = LocalTime.parse(startTimeStr);
        return Stream.iterate(startTime, Duration.ofHours(intervalHours)::addTo)
                .limit(count)
                .map(DateTimeFormatter.ISO_LOCAL_TIME::format)
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        System.out.println("按秒递增: " + bySeconds("10:00:00", 2, 5));
        // 预期输出: [10:00:00, 10:00:02, 10:00:04, 10:00:06, 10:00:08]

        System.out.println("按分钟递增: " + byMinutes("10:00:00", 5, 5));
        // 预期输出: [10:00:00, 10:05:00, 10:10:00, 10:15:00, 10:20:00]

        System.out.println("按小时递增: " + byHours("10:00:00", 1, 5));
        // 预期输出: [10:00:00, 11:00:00, 12:00:00, 13:00:00, 14:00:00]
    }
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。