高效查找嵌套对象中最新日期对应外部对象ID的Stream API实践

{
    "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 InnerObject {
    private String id;
    private int date; // 使用int简化日期比较，实际应用中建议使用java.time.LocalDate/LocalDateTime

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

    public String getId() {
        return id;
    }

    public int getDate() {
        return date;
    }

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

// 外部对象
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 + '}';
    }
}

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 Optional<String> findOutterObjectIdWithMostRecentInnerObject(
            List<OutterObject> outterObjects, String targetInnerId) {

        return outterObjects.stream()
                // 步骤1: 扁平化并创建(OutterObject ID, InnerObject) 对
                // 将每个OutterObject与其内部的InnerObject进行配对，生成一个包含OutterObject ID和InnerObject的流
                .flatMap(outer -> outer.getInnerObject().stream()
                                       .map(inner -> new AbstractMap.SimpleEntry<>(outer.getId(), inner)))

                // 步骤2: 筛选符合条件的InnerObject
                // 过滤出那些InnerObject的ID与目标ID匹配的对
                .filter(entry -> entry.getValue().getId().equals(targetInnerId))

                // 步骤3: 找出日期最大的InnerObject
                // 使用max操作和Comparator来找到Stream中日期最大的InnerObject所在的对
                .max(Comparator.comparing(entry -> entry.getValue().getDate()))

                // 步骤4: 提取并返回OutterObject的ID
                // 如果找到了最大日期对应的对，则从中提取OutterObject的ID；否则返回Optional.empty()
                .map(AbstractMap.SimpleEntry::getKey);
    }

    public static void main(String[] args) {
        // 示例数据
        List<OutterObject> data = 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 targetId = "ab";
        Optional<String> resultId = findOutterObjectIdWithMostRecentInnerObject(data, targetId);

        if (resultId.isPresent()) {
            System.out.println("OutterObject ID with the most recent InnerObject (ID: \"" + targetId + "\"): " + resultId.get()); // 预期输出: def
        } else {
            System.out.println("No matching InnerObject found for ID: " + targetId);
        }

        // 测试没有匹配的情况
        String nonExistentId = "xyz";
        Optional<String> noResult = findOutterObjectIdWithMostRecentInnerObject(data, nonExistentId);
        if (noResult.isPresent()) {
            System.out.println("OutterObject ID with the most recent InnerObject (ID: \"" + nonExistentId + "\"): " + noResult.get());
        } else {
            System.out.println("No matching InnerObject found for ID: " + nonExistentId); // 预期输出: No matching InnerObject found for ID: xyz
        }
    }
}