Java8Stream按日期分组取最新记录教程

对于一个文章开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《Java 8 Stream与SQL按日期分组取最新记录教程》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

1. 问题背景与数据模型

在实际应用中，我们经常需要从一系列记录中筛选出每个分组在特定时间维度上的最新数据。例如，给定一个包含货币交易信息的列表，其中每条记录包含ID、货币名称和最后接收时间戳，我们需要为每种货币的每一天，找出当天接收到的最新一条记录。

考虑以下 Currency 数据模型：

import java.time.LocalDateTime;
import java.util.Objects;

class Currency {
    private Integer id;
    private String name;
    private LocalDateTime lastReceived;

    public Currency(Integer id, String name, LocalDateTime lastReceived) {
        this.id = id;
        this.name = name;
        this.lastReceived = lastReceived;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public LocalDateTime getLastReceived() {
        return lastReceived;
    }

    @Override
    public String toString() {
        return "Currency{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", lastReceived=" + lastReceived +
               '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Currency currency = (Currency) o;
        return Objects.equals(id, currency.id) && Objects.equals(name, currency.name) && Objects.equals(lastReceived, currency.lastReceived);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, lastReceived);
    }
}

假设我们有以下数据库记录：

我们期望的结果是针对每种货币的每一天，获取时间戳最新的记录：

2. 使用Java 8 Stream API实现

Java 8 Stream API提供了强大的功能来处理集合数据。解决此问题的核心思路是：首先按货币名称和日期进行分组，然后在每个分组中找出 lastReceived 时间戳最大的那条记录。

2.1 获取所有货币类型在各日期的最新记录

为了实现“按货币名称和日期分组”，我们可以创建一个复合键，将货币名称和 lastReceived 字段的日期部分（toLocalDate()）组合起来。然后，使用 Collectors.groupingBy 进行分组，并结合 Collectors.collectingAndThen 与 Collectors.maxBy 来选择每个分组中时间戳最新的记录。

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class CurrencyProcessor {

    public static void main(String[] args) {
        List<Currency> data = Arrays.asList(
                new Currency(1, "USD", LocalDateTime.parse("2022-05-18T09:04:01.545")),
                new Currency(2, "USD", LocalDateTime.parse("2022-05-18T08:04:01.545")),
                new Currency(3, "USD", LocalDateTime.parse("2022-05-19T08:04:01.545")),
                new Currency(4, "USD", LocalDateTime.parse("2022-05-20T08:04:01.545")),
                new Currency(5, "USD", LocalDateTime.parse("2022-05-20T11:04:01.545")),
                new Currency(6, "BUSD", LocalDateTime.parse("2022-05-18T08:04:01.545"))
        );

        // 1. 获取所有货币类型在各日期的最新记录
        List<Currency> lastByDateForAllCurrencies = new ArrayList<>(data
                .stream()
                .collect(Collectors.groupingBy(
                        // 复合键：货币名称 + 日期
                        curr -> Arrays.asList(curr.getName(), curr.getLastReceived().toLocalDate()),
                        // 在每个分组中找到lastReceived最大的记录
                        Collectors.collectingAndThen(
                                Collectors.maxBy(Comparator.comparing(Currency::getLastReceived)),
                                Optional::get // 将Optional<Currency>转换为Currency
                        )
                ))
                .values()); // 获取Map中的所有值

        System.out.println("所有货币类型在各日期的最新记录 (未排序):");
        lastByDateForAllCurrencies.forEach(System.out::println);

        // 如果需要排序，可以对结果列表进行排序
        lastByDateForAllCurrencies.sort(
                Comparator.comparing(Currency::getLastReceived)
                          .thenComparing(Currency::getName)
        );
        System.out.println("\n所有货币类型在各日期的最新记录 (已排序):");
        lastByDateForAllCurrencies.forEach(System.out::println);
    }
}

代码解析：

• Collectors.groupingBy(curr -> Arrays.asList(curr.getName(), curr.getLastReceived().toLocalDate()), ...)：这是核心分组逻辑。它根据 Currency 对象的 name 属性和 lastReceived 属性的日期部分（通过 toLocalDate() 获取）创建一个复合键。所有具有相同复合键的 Currency 对象将被分到同一个组中。
• Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparing(Currency::getLastReceived)), Optional::get)：
  • Collectors.maxBy(Comparator.comparing(Currency::getLastReceived)): 这是下游收集器，它在每个分组内部查找 lastReceived 时间戳最大的 Currency 对象。maxBy 返回一个 Optional。
  • Optional::get: collectingAndThen 的第二个参数是一个函数，用于处理 maxBy 的结果。由于我们知道每个分组至少会有一个元素（因为是 groupingBy 创建的），所以可以直接调用 get() 来获取 Optional 中的值。
• .values()：groupingBy 返回一个 Map, Currency>。我们只关心筛选出来的 Currency 对象，所以调用 values() 获取所有 Currency 实例的集合。
• new ArrayList<>(...)：将 Map.values() 返回的 Collection 转换为 ArrayList，以便后续进行排序操作。
• lastByDateForAllCurrencies.sort(...)：如果需要按特定顺序（例如按日期和货币名称）显示结果，可以对生成的列表进行排序。

2.2 获取特定货币类型在各日期的最新记录

如果只需要针对特定的货币（例如 "USD"）执行此操作，可以在 stream() 之后添加一个 filter 操作。这样，分组键就可以简化为仅包含日期。

        // 2. 获取特定货币类型（例如USD）在各日期的最新记录
        String targetCurrency = "USD";
        List<Currency> lastUSDByDate = new ArrayList<>(data
                .stream()
                .filter(curr -> targetCurrency.equalsIgnoreCase(curr.getName())) // 过滤特定货币
                .collect(Collectors.groupingBy(
                        curr -> curr.getLastReceived().toLocalDate(), // 简化分组键为日期
                        Collectors.collectingAndThen(
                                Collectors.maxBy(Comparator.comparing(Currency::getLastReceived)),
                                Optional::get
                        )
                ))
                .values());

        // 对结果进行排序
        lastUSDByDate.sort(Comparator.comparing(Currency::getLastReceived));

        System.out.println("\n特定货币 (" + targetCurrency + ") 在各日期的最新记录:");
        lastUSDByDate.forEach(System.out::println);

代码解析：

• .filter(curr -> targetCurrency.equalsIgnoreCase(curr.getName()))：在分组之前，先筛选出 name 属性与 targetCurrency 匹配的 Currency 对象。
• Collectors.groupingBy(curr -> curr.getLastReceived().toLocalDate(), ...)：由于已经过滤了货币类型，现在只需按日期进行分组即可。

3. 使用SQL窗口函数实现

对于存储在数据库中的数据，使用SQL查询通常是更高效和直接的方式。许多现代数据库（如PostgreSQL、MySQL 8+、Oracle SQL Server）都支持窗口函数，这使得按分组和排序获取最新/最旧记录变得非常简单。

以下是一个使用PostgreSQL的SQL窗口函数实现此逻辑的示例：

SELECT id, name, last_received
FROM (
    SELECT c.*,
           ROW_NUMBER() OVER (
               PARTITION BY name, to_char(last_received, 'yyyy-MM-dd')
               ORDER BY last_received DESC
           ) AS rn -- 为每个(name, date)分区内的记录按last_received降序编号
    FROM Currency c
    WHERE c.name = :currName -- 可选：如果只需要特定货币
) tbl
WHERE rn = 1 -- 选取每个分区中编号为1（即最新）的记录
ORDER BY last_received; -- 按日期排序最终结果

SQL查询解析：

• ROW_NUMBER() OVER (PARTITION BY name, to_char(last_received, 'yyyy-MM-dd') ORDER BY last_received DESC)：这是核心的窗口函数。
  • PARTITION BY name, to_char(last_received, 'yyyy-MM-dd')：这定义了分区规则。它会根据 name 字段和 last_received 字段的日期部分（to_char 用于提取日期字符串）将数据分成不同的组。
  • ORDER BY last_received DESC：在每个分区内部，记录会按照 last_received 字段降序排列（最新的在前）。
  • ROW_NUMBER() AS rn：为每个分区内排序后的记录分配一个从1开始的行号。因此，rn = 1 的记录就是每个分区中 last_received 最新的那条。
• WHERE rn = 1：在外部查询中，我们筛选出 rn 为1的记录，从而得到每个分组中最新的数据。
• WHERE c.name = :currName：如果只需要查询特定货币，可以在内层查询中添加此过滤条件。
• ORDER BY last_received：对最终结果按时间戳进行排序。

注意事项：

• JPA（Java Persistence API）目前通常不直接支持将窗口函数映射到实体查询语言（JPQL）。这意味着如果需要使用窗口函数，可能需要通过 nativeQuery = true 来执行原生SQL查询，或者在服务层手动处理。
• 不同的数据库系统在日期格式化函数上可能有所不同（例如，MySQL可以使用 DATE(last_received)，SQL Server可以使用 CONVERT(DATE, last_received)）。

4. 总结与最佳实践

本教程提供了两种主要方法来解决按分组和日期获取最新记录的问题：

1. Java 8 Stream API： 适用于数据量不大，或者数据已经加载到内存中的场景。它提供了灵活、声明式的数据处理方式，使代码简洁易读。通过 groupingBy、maxBy 和 collectingAndThen 可以优雅地实现复杂的分组聚合逻辑。
2. SQL窗口函数： 适用于数据量大，或者希望在数据库层面进行高效过滤和聚合的场景。数据库通常在处理这类查询时具有更高的性能，尤其是在索引优化的情况下。

选择哪种方法取决于具体情况：

• 如果数据源是数据库，并且性能是关键因素，优先考虑在数据库层面使用SQL窗口函数。
• 如果数据已经存在于Java集合中，或者数据量相对较小，Java 8 Stream API是一个很好的选择，可以避免额外的数据库往返。

在实际开发中，理解这两种方法的原理和适用场景，能够帮助开发者选择最合适、最高效的解决方案。

到这里，我们也就讲完了《Java8Stream按日期分组取最新记录教程》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！