使用Java Stream高效查找嵌套对象中符合最新日期条件的外部对象

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; // Assuming date is a string, e.g., "1", "9". For real dates, use 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.ArrayList;

public class NestedObjectSearch {

    public static void main(String[] args) {
        List<OutterObject> outterObjects = new ArrayList<>();

        // 第一个 OutterObject
        outterObjects.add(new OutterObject("abc", Arrays.asList(
                new InnerObject("ab", "1"),
                new InnerObject("de", "2"),
                new InnerObject("ab", "3")
        )));

        // 第二个 OutterObject
        outterObjects.add(new OutterObject("def", Arrays.asList(
                new InnerObject("ab", "9"),
                new InnerObject("de", "3"),
                new InnerObject("ab", "1")
        )));

        String targetInnerId = "ab"; // 目标内部对象ID

        // 调用查找方法
        Optional<OutterObject> result = findOutterObjectWithMostRecentInnerDate(outterObjects, targetInnerId);

        if (result.isPresent()) {
            System.out.println("找到的 OutterObject ID: " + result.get().getId()); // 预期输出: def
        } else {
            System.out.println("未找到符合条件的 OutterObject。");
        }
    }

    // ... 查找方法将在下一节实现
}

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

// (OutterObject and InnerObject definitions as above)

public class NestedObjectSearch {

    public static void main(String[] args) {
        // (Sample data initialization as above)
        List<OutterObject> outterObjects = new ArrayList<>();

        outterObjects.add(new OutterObject("abc", Arrays.asList(
                new InnerObject("ab", "1"),
                new InnerObject("de", "2"),
                new InnerObject("ab", "3")
        )));

        outterObjects.add(new OutterObject("def", Arrays.asList(
                new InnerObject("ab", "9"),
                new InnerObject("de", "3"),
                new InnerObject("ab", "1")
        )));

        String targetInnerId = "ab";

        Optional<OutterObject> result = findOutterObjectWithMostRecentInnerDate(outterObjects, targetInnerId);

        if (result.isPresent()) {
            System.out.println("找到的 OutterObject ID: " + result.get().getId()); // 预期输出: def
        } else {
            System.out.println("未找到符合条件的 OutterObject。");
        }
    }

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

        return outterObjects.stream()
                // 1. 扁平化处理：将每个OutterObject及其包含的InnerObject配对
                //    使用AbstractMap.SimpleEntry来存储 <InnerObject, OutterObject> 的关联
                .flatMap(outer -> outer.getInnerObject().stream()
                        .map(inner -> new AbstractMap.SimpleEntry<>(inner, outer)))
                // 2. 过滤：只保留InnerObject的ID与目标ID匹配的配对
                .filter(entry -> entry.getKey().getId().equals(targetInnerId))
                // 3. 查找最大值：从过滤后的配对中，找出InnerObject日期最大的那个配对
                //    Comparator.comparing根据InnerObject的getDate方法进行比较
                .max(Comparator.comparing(entry -> entry.getKey().getDate()))
                // 4. 映射：如果找到了最大值配对，则提取其关联的OutterObject
                //    AbstractMap.SimpleEntry::getValue 返回的是 OutterObject
                .map(AbstractMap.SimpleEntry::getValue);
    }
}