Java 8 如何基于Foo的status属性排序List<Object>集合

嘿，这个场景我之前做项目时也碰到过，没法改List<Object>的泛型类型确实有点小麻烦，但有几种靠谱的解决方案，我给你详细说说：

首先得确认你的Foo类已经提供了获取status的公共方法，比如public String getStatus()——毕竟私有属性没法直接访问，这是实现排序的基础哈。

方案1：传统Comparator写法（兼容Java 7及更早版本） #

直接用Collections.sort()方法，传入自定义的Comparator，在逻辑里把Object强转为Foo后比较status：

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

// 示例Foo类（确保有getStatus方法）
class Foo {
    private String name;
    private String status;

    public Foo(String name, String status) {
        this.name = name;
        this.status = status;
    }

    public String getStatus() {
        return status;
    }

    // 可选：重写toString方便测试输出
    @Override
    public String toString() {
        return "Foo{name='" + name + "', status='" + status + "'}";
    }
}

public class SortDemo {
    public static void main(String[] args) {
        List<Object> ls = new ArrayList<Object>();
        ls.add(new Foo("任务A", "pending"));
        ls.add(new Foo("任务B", "completed"));
        ls.add(new Foo("任务C", "in_progress"));

        // 执行排序
        Collections.sort(ls, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                // 这里假设集合里全是Foo对象，如果怕混入其他类型，可以加类型检查
                Foo foo1 = (Foo) o1;
                Foo foo2 = (Foo) o2;
                // 按status字符串自然顺序排序
                return foo1.getStatus().compareTo(foo2.getStatus());
            }
        });

        // 测试输出排序结果
        for (Object obj : ls) {
            System.out.println(obj);
        }
    }
}

如果担心集合里混入非Foo对象，一定要加类型检查避免运行时异常：

@Override
public int compare(Object o1, Object o2) {
    if (!(o1 instanceof Foo) || !(o2 instanceof Foo)) {
        // 可以抛出异常，或者自定义规则（比如把非Foo对象放到最后）
        throw new ClassCastException("集合中包含非Foo类型的对象");
    }
    Foo foo1 = (Foo) o1;
    Foo foo2 = (Foo) o2;
    return foo1.getStatus().compareTo(foo2.getStatus());
}

方案2：Java 8+ 简化写法（Lambda/Stream） #

Java 8之后的语法能让代码简洁很多，推荐用这两种方式：

方式A：直接排序原集合 #

用Lambda表达式替代匿名内部类，代码更紧凑：

Collections.sort(ls, (o1, o2) -> {
    Foo foo1 = (Foo) o1;
    Foo foo2 = (Foo) o2;
    return foo1.getStatus().compareTo(foo2.getStatus());
});

甚至可以再简化成一行：

Collections.sort(ls, Comparator.comparing(o -> ((Foo) o).getStatus()));

方式B：用Stream生成新的排序集合（不修改原集合） #

如果不想改动原集合的顺序，用Stream流处理生成新的排序后的List<Object>：

// Java 16+ 可用toList()，更早版本用.collect(Collectors.toList())
List<Object> sortedList = ls.stream()
    .filter(obj -> obj instanceof Foo) // 可选：过滤掉非Foo对象
    .sorted(Comparator.comparing(obj -> ((Foo) obj).getStatus()))
    .toList();

进阶：自定义status排序规则 #

如果不是按字符串自然顺序排序，而是需要自定义优先级（比如completed > in_progress > pending），可以用一个Map定义优先级，再比较：

import java.util.HashMap;
import java.util.Map;

// 定义优先级映射
Map<String, Integer> statusPriority = new HashMap<>();
statusPriority.put("completed", 3);
statusPriority.put("in_progress", 2);
statusPriority.put("pending", 1);

// 按自定义优先级排序
Collections.sort(ls, (o1, o2) -> {
    Foo foo1 = (Foo) o1;
    Foo foo2 = (Foo) o2;
    return Integer.compare(statusPriority.get(foo1.getStatus()), statusPriority.get(foo2.getStatus()));
});

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