查找嵌套对象中具有最新日期特定内层对象的父级ID

{
    "OutterObject": [
        {
            "id": "abc",
            "InnerObject": [
                {
                    "id": "ab",
                    "date": "1"
                },
                {
                    "id": "de",
                    "date": "2"
                },
                {
                    "id": "ab",
                    "date": "3"
                }
            ]
        },
        {
            "id": "def",
            "InnerObject": [
                {
                    "id": "ab",
                    "date": "9"
                },
                {
                    "id": "de",
                    "date": "3"
                },
                {
                    "id": "ab",
                    "date": "1"
                }
            ]
        }
    ]
}

import java.util.List;
import java.util.Optional;
import java.util.Comparator;
import java.util.AbstractMap; // For SimpleEntry

// 外层对象
class OutterObject {
    private String id;
    private List<InnerObject> 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 + '}';
    }
}

// 内层对象
class InnerObject {
    private String id;
    private String date; // 简化为String，实际应为Date/LocalDateTime

    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 + "'}";
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Comparator;
import java.util.AbstractMap; // For SimpleEntry

public class NestedObjectSearch {

    public static void main(String[] args) {
        // 示例数据构建
        List<OutterObject> outterObjects = Arrays.asList(
            new OutterObject("abc", Arrays.asList(
                new InnerObject("ab", "1"),
                new InnerObject("de", "2"),
                new InnerObject("ab", "3")
            )),
            new OutterObject("def", Arrays.asList(
                new InnerObject("ab", "9"),
                new InnerObject("de", "3"),
                new InnerObject("ab", "1")
            ))
        );

        String targetInnerId = "ab";

        // Stream 解决方案
        Optional<String> resultOutterId = outterObjects.stream()
            // 步骤1: 扁平化OutterObject的InnerObject列表，并创建(OutterObject, InnerObject)配对
            .flatMap(outer -> outer.getInnerObject().stream()
                                   .map(inner -> new AbstractMap.SimpleEntry<>(outer, inner)))
            // 步骤2: 筛选出InnerObject ID与目标ID匹配的配对
            .filter(entry -> entry.getValue().getId().equals(targetInnerId))
            // 步骤3: 找出InnerObject日期最新的配对
            // 注意：这里使用String的自然顺序比较，对于数字字符串有效。
            // 实际日期应使用Date或LocalDateTime的比较器。
            .max(Comparator.comparing(entry -> entry.getValue().getDate()))
            // 步骤4: 如果找到，则从配对中提取OutterObject的ID
            .map(entry -> entry.getKey().getId());

        // 处理结果
        resultOutterId.ifPresentOrElse(
            id -> System.out.println("找到的外层对象ID: " + id),
            () -> System.out.println("未找到符合条件的外层对象。" +
                                   "可能原因：目标内层ID不存在，或数据列表为空。")
        );
    }
}