Java Stream：高效查找嵌套对象中最新数据对应的父对象ID

import java.util.List;
import java.util.Objects;

// 内部对象类
class InnerObject {
    private String id;
    private String date; // 假设日期为字符串，可直接比较或转换为数值/日期类型

    public InnerObject(String id, String date) {
        this.id = id;
        this.date = date;
    }

    public String getId() {
        return id;
    }

    public String getDate() {
        return date;
    }

    @Override
    public String toString() {
        return "InnerObject{id='" + id + "', date='" + date + "'}";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        InnerObject that = (InnerObject) o;
        return Objects.equals(id, that.id) && Objects.equals(date, that.date);
    }

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

// 外部对象类
class OutterObject {
    private String id;
    private List<InnerObject> innerObject; // 注意：JSON中是"InnerObject"

    public OutterObject(String id, List<InnerObject> innerObject) {
        this.id = id;
        this.innerObject = innerObject;
    }

    public String getId() {
        return id;
    }

    public List<InnerObject> getInnerObject() {
        return innerObject;
    }

    @Override
    public String toString() {
        return "OutterObject{id='" + id + "', innerObject=" + innerObject + "}";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OutterObject that = (OutterObject) o;
        return Objects.equals(id, that.id) && Objects.equals(innerObject, that.innerObject);
    }

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

import java.util.AbstractMap;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public class OuterObjectFinder {

    /**
     * 查找包含特定InnerObject ID且其日期最新的OutterObject的ID。
     *
     * @param outterObjects 外部对象列表
     * @param targetInnerId 目标内部对象ID
     * @return 包含最新日期的InnerObject的OutterObject ID，如果未找到则返回Optional.empty()
     */
    public static Optional<String> findOuterObjectIdWithMostRecentInnerObject(
            List<OutterObject> outterObjects, String targetInnerId) {

        return outterObjects.stream()
                // 步骤 1: 扁平化并配对 (OutterObject, InnerObject)
                // 为每个OutterObject中的InnerObject创建一个Pair，以便后续能追踪到其父对象
                .flatMap(outer -> outer.getInnerObject().stream()
                        .map(inner -> new AbstractMap.SimpleEntry<>(outer, inner)))
                // 步骤 2: 过滤目标InnerObject ID
                // 仅保留InnerObject ID与目标ID匹配的配对
                .filter(entry -> entry.getValue().getId().equals(targetInnerId))
                // 步骤 3: 找出具有最大日期的配对
                // 使用Comparator比较InnerObject的date字段，找到日期最新的配对
                // 注意：如果date是字符串，这里会进行字典序比较。对于数值型日期字符串（如"1", "9"），
                // 字典序比较是正确的；对于标准日期格式，需要转换为日期类型进行比较。
                .max(Comparator.comparing(entry -> entry.getValue().getDate()))
                // 步骤 4: 提取OutterObject ID
                // 从找到的配对中，获取其对应的OutterObject的ID
                .map(entry -> entry.getKey().getId());
    }

    public static void main(String[] args) {
        // 示例数据（根据问题描述中的JSON结构）
        List<OutterObject> data = List.of(
                new OutterObject("abc", List.of(
                        new InnerObject("ab", "1"),
                        new InnerObject("de", "2"),
                        new InnerObject("ab", "3") // 内部ID为"ab"，日期为"3"
                )),
                new OutterObject("def", List.of(
                        new InnerObject("ab", "9"), // 内部ID为"ab"，日期为"9"，这是所有"ab"中最新的
                        new InnerObject("de", "3"),
                        new InnerObject("ab", "1")
                ))
        );

        String targetId = "ab";
        Optional<String> result = findOuterObjectIdWithMostRecentInnerObject(data, targetId);

        result.ifPresentOrElse(
                id -> System.out.println("找到的OutterObject ID: " + id),
                () -> System.out.println("未找到匹配InnerObject ID '" + targetId + "'的OutterObject。")
        );
        // 预期输出: 找到的OutterObject ID: def

        String targetIdNotFound = "xyz";
        Optional<String> resultNotFound = findOuterObjectIdWithMostRecentInnerObject(data, targetIdNotFound);
        resultNotFound.ifPresentOrElse(
                id -> System.out.println("找到的OutterObject ID: " + id),
                () -> System.out.println("未找到匹配InnerObject ID '" + targetIdNotFound + "'的OutterObject。")
        );
        // 预期输出: 未找到匹配InnerObject ID 'xyz'的OutterObject。
    }
}