如何按日期对两个不同对象列表排序并依次处理？

嘿，这个需求其实很好实现，核心就是把两个不同类型但共享updateDate字段的列表合并后按日期升序排列对吧？我给你用Java写个实际可运行的例子，顺便讲清楚几种实现思路：

方法一：直接合并+类型判断排序（无需修改原类） #

如果你没办法修改Object1和Object2的代码，这种方式最直接：

步骤说明 #

1. 合并列表：把两个不同类型的列表都放到一个通用的List<Object>集合里，方便统一排序
2. 自定义排序规则：通过instanceof判断对象类型，提取对应的updateDate字段进行比较
3. 遍历处理：排序完成后，逐个判断对象类型并执行对应的处理逻辑

完整代码示例 #

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

public class MergedDateSort {
    public static void main(String[] args) {
        // 初始化示例数据
        List<Object1> list1 = new ArrayList<>();
        list1.add(new Object1("Q3月度数据", Date.valueOf("2017-10-01"), 1500));
        list1.add(new Object1("9月上旬数据", Date.valueOf("2017-09-03"), 800));

        List<Object2> list2 = new ArrayList<>();
        list2.add(new Object2("Q3季度总结", Date.valueOf("2017-10-15"), "业务复盘"));
        list2.add(new Object2("9月初始记录", Date.valueOf("2017-09-01"), "启动阶段"));

        // 合并两个列表
        List<Object> combinedList = new ArrayList<>();
        combinedList.addAll(list1);
        combinedList.addAll(list2);

        // 按updateDate升序排序
        combinedList.sort(new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                Date date1 = extractUpdateDate(o1);
                Date date2 = extractUpdateDate(o2);
                // 升序排序，直接返回compareTo结果即可
                return date1.compareTo(date2);
            }

            private Date extractUpdateDate(Object obj) {
                if (obj instanceof Object1) {
                    return ((Object1) obj).getUpdateDate();
                } else if (obj instanceof Object2) {
                    return ((Object2) obj).getUpdateDate();
                }
                throw new IllegalArgumentException("不支持的对象类型");
            }
        });

        // 依次处理每个对象
        for (Object obj : combinedList) {
            if (obj instanceof Object1) {
                Object1 data = (Object1) obj;
                System.out.printf("处理Object1 | 日期: %s | 描述: %s | 数值: %d%n", 
                        data.getUpdateDate(), data.getDescription(), data.getValue());
                // 这里替换成你的实际处理逻辑
            } else if (obj instanceof Object2) {
                Object2 record = (Object2) obj;
                System.out.printf("处理Object2 | 日期: %s | 描述: %s | 子描述: %s%n", 
                        record.getUpdateDate(), record.getDescription(), record.getDescription2());
                // 这里替换成你的实际处理逻辑
            }
        }
    }

    // 假设的Object1类（模拟你的结构）
    static class Object1 {
        private String description;
        private Date updateDate;
        private int value;

        public Object1(String description, Date updateDate, int value) {
            this.description = description;
            this.updateDate = updateDate;
            this.value = value;
        }

        // Getter方法
        public String getDescription() { return description; }
        public Date getUpdateDate() { return updateDate; }
        public int getValue() { return value; }
    }

    // 假设的Object2类（模拟你的结构）
    static class Object2 {
        private String description;
        private Date updateDate;
        private String description2;

        public Object2(String description, Date updateDate, String description2) {
            this.description = description;
            this.updateDate = updateDate;
            this.description2 = description2;
        }

        // Getter方法
        public String getDescription() { return description; }
        public Date getUpdateDate() { return updateDate; }
        public String getDescription2() { return description2; }
    }
}

方法二：用Java 8 Stream简化代码 #

如果用Java 8及以上版本，可以用Stream API让合并和排序的代码更简洁：

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

// ... 省略Object1和Object2的定义（和上面一致）
public class StreamMergedSort {
    public static void main(String[] args) {
        // 初始化list1和list2（和上面一致）

        // 合并+排序一步完成
        List<Object> combinedList = Stream.concat(list1.stream(), list2.stream())
                .sorted((o1, o2) -> {
                    Date date1 = extractUpdateDate(o1);
                    Date date2 = extractUpdateDate(o2);
                    return date1.compareTo(date2);
                })
                .collect(Collectors.toList());

        // 遍历处理（和上面一致）
    }

    private static Date extractUpdateDate(Object obj) {
        if (obj instanceof Object1) {
            return ((Object1) obj).getUpdateDate();
        } else if (obj instanceof Object2) {
            return ((Object2) obj).getUpdateDate();
        }
        throw new IllegalArgumentException("不支持的对象类型");
    }
}

方法三：定义统一接口（更优雅的面向对象方式） #

如果可以修改Object1和Object2的代码，建议定义一个统一的接口，让两个类都实现这个接口，这样排序时就不用做类型判断了：

步骤说明 #

1. 定义一个包含getUpdateDate()方法的接口
2. 让Object1和Object2都实现这个接口
3. 合并时用接口类型的列表，排序逻辑会更简洁

代码示例 #

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

// 统一接口
interface HasUpdateDate {
    Date getUpdateDate();
}

// Object1实现接口
static class Object1 implements HasUpdateDate {
    private String description;
    private Date updateDate;
    private int value;

    // 构造函数和Getter方法（和之前一致）
    @Override
    public Date getUpdateDate() {
        return updateDate;
    }
}

// Object2实现接口
static class Object2 implements HasUpdateDate {
    private String description;
    private Date updateDate;
    private String description2;

    // 构造函数和Getter方法（和之前一致）
    @Override
    public Date getUpdateDate() {
        return updateDate;
    }
}

public class InterfaceBasedSort {
    public static void main(String[] args) {
        List<Object1> list1 = new ArrayList<>();
        List<Object2> list2 = new ArrayList<>();
        // 初始化数据（和之前一致）

        // 合并成接口类型的列表
        List<HasUpdateDate> combinedList = new ArrayList<>();
        combinedList.addAll(list1);
        combinedList.addAll(list2);

        // 直接按接口方法排序，无需类型判断
        combinedList.sort(Comparator.comparing(HasUpdateDate::getUpdateDate));

        // 遍历处理时还是需要判断类型执行不同逻辑
        for (HasUpdateDate item : combinedList) {
            if (item instanceof Object1) {
                Object1 data = (Object1) item;
                // 处理逻辑
            } else if (item instanceof Object2) {
                Object2 record = (Object2) item;
                // 处理逻辑
            }
        }
    }
}

以上三种方式都能实现你要的排序效果，按你的实际场景选就行～

内容的提问来源于stack exchange，提问作者JoeyD