Java泛型三元组排序报错：无法对Object类型应用'>'运算符

你的核心问题是：Object类型无法直接用>运算符比较，且当前泛型设计没有保证元素的可比性和同类型约束。以下是两种可行方案：

方案一：统一泛型为可比较类型（推荐） #

直接让Triple的三个元素为同一可比较类型，从根源避免类型混乱和比较问题：

import java.util.ArrayList;

public class Triple<T extends Comparable<? super T>> {
    private T t;
    private T s;
    private T u;
    private ArrayList<T> array = new ArrayList<>();

    Triple(T t, T s, T u) {
        setT(t);
        setS(s);
        setU(u);
        array.add(this.t);
        array.add(this.s);
        array.add(this.u);
    }

    public void setT(T t) {
        this.t = t;
    }

    public void setS(T s) {
        this.s = s;
    }

    public void setU(T u) {
        this.u = u;
    }

    public T getFirst() {
        return t;
    }

    public T getSecond() {
        return s;
    }

    public T getThird() {
        return u;
    }

    @Override
    public String toString() {
        return t + "\n" + s + "\n" + u + "\n";
    }

    // 因为泛型已约束为同一类型，此方法可简化为直接返回true，或保留原逻辑做双重校验
    public boolean isHomogeneous() {
        return true;
        // 若要严格校验对象的类实例，可保留原代码：
        // return t.getClass() == s.getClass() && t.getClass() == u.getClass();
    }

    public void tripleSort() {
        // 直接用Comparable的compareTo方法替代>运算符
        for (int i = 1; i < array.size(); ++i) {
            T key = array.get(i);
            int j = i - 1;
            // compareTo返回正数表示当前对象大于参数
            while (j > -1 && array.get(j).compareTo(key) > 0) {
                array.set(j + 1, array.get(j));
                j--;
            }
            array.set(j + 1, key);
        }
    }
}

关键改动说明： #

• 泛型定义改为T extends Comparable<? super T>，确保类型支持比较操作
• 将原有的T、S、U三个泛型统一为T，保证元素类型一致
• ArrayList从Object改为T，避免类型转换
• 排序逻辑中用compareTo方法替代>，符合Java的比较规范

方案二：保留原泛型结构，动态校验并转换类型 #

如果必须保留T、S、U三个不同泛型，可在排序前先校验是否为同类型且可比较，再强制转换为Comparable进行操作（存在类型转换风险，需谨慎）：

import java.util.ArrayList;

public class Triple<T, S, U> {
    private T t;
    private S s;
    private U u;
    private ArrayList<Object> array = new ArrayList<>();

    Triple(T t, S s, U u) {
        setT(t);
        setS(s);
        setU(u);
        array.add(this.t);
        array.add(this.s);
        array.add(this.u);
    }

    // 其余get/set、toString、isHomogeneous方法保持不变

    public void tripleSort() {
        // 先校验是否为同类型且实现了Comparable接口
        if (!isHomogeneous() || !(t instanceof Comparable)) {
            throw new IllegalArgumentException("元素必须是同一可比较类型");
        }
        // 强制转换为Comparable类型进行排序
        for (int i = 1; i < array.size(); ++i) {
            Comparable key = (Comparable) array.get(i);
            int j = i - 1;
            while (j > -1 && ((Comparable) array.get(j)).compareTo(key) > 0) {
                array.set(j + 1, array.get(j));
                j--;
            }
            array.set(j + 1, key);
        }
    }
}

关键改动说明： #

• 排序前先调用isHomogeneous校验同类型，同时判断元素是否实现Comparable
• 将Object强制转换为Comparable，使用compareTo进行比较
• 若不满足条件则抛出异常，避免运行时类型转换错误

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