Java 比较三个通用元素-解网

问：

如果元素是同一类型，我想比较元素的集合（ArrayList）。一开始我不知道元素是什么类型（泛型类型），所以我决定使用 Object 类型。但我仍然无法比较它们。问题出在函数中。
警告是：

如果您对该问题有任何可能的解决方案，并且您告诉我，我将不胜感激。<3
三人间.javatriplesort()Operator '>' cannot be applied to 'java.lang.Object', 'java.lang.Object'.

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<Object>();

    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);
    }

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

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

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

    public T getFirst() {
        return t;
    }

    public S getSecond() {
        return s;
    }

    public U getThird() {
        return u;
    }

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

    public boolean isHomogeneous() {
        return t.getClass() == s.getClass() && t.getClass() == u.getClass();
    }

    public void tripleSort() {
        try {
            for (int i = 1; i < array.size(); ++i) {
                Object key = array.get(i);
                int j = i - 1;
                while (j > -1 && array.get(i) > key) {
                    array.set(j + 1, array.get(j));
                    j--;
                }
                array.set(j + 1, key);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Java 排序比较

关系运算符，，只能用于比较数值基元类型。显然，您可以将其与对象一起使用。<<=>>=
要比较引用类型，您可以使用比较器，或者这些对象可以实现可比较接口（即它们基本上知道如何比较自己）。但是，由于比较和，或者和，您将如何处理它，因此无法做到这一点？因此，这些接口是通用的，不能与类型的对象一起使用。BigDecimalBooleanStringHashMapComparator<T>U

也就是说，您将无法对这些属于不同类型的对象做很多事情（绝对不能对它们进行排序）。Triple<T, S, U>

因此，如果您需要一个包含三种不同类型引用的数据载体，那就太好了。它仍然有用，但不要对它抱有太大期望。

Java 16 记录非常适合这个角色：

public record Triple<T, S, U>(T first, S second, U third) {}

但是，如果您需要能够对这些值进行操作，将它们相互比较，请考虑将更改为仅保存类型的元素。TripleT

下面是如何实现它的示例：

public static class Triple<T> {
    private List<T> list = new ArrayList<>(3);
    private Comparator<T> comp;
    
    private Triple(T first, T second, T third, Comparator<T> comp) { // no way and no need to invoke this constructor outside the class
        this.comp = comp;
        Collections.addAll(list, first, second, third);
    }
    
    public static <T> Triple<T> getInstance(T first, T second, T third, Comparator<T> comp) {
        Triple<T> triple = new Triple<>(first, second, third, comp);
        triple.init();
        return triple;
    }
    
    public void init() {
        list.sort(comp);
    }
    
    public T getFirst() {
        return list.get(0);
    }
    
    public T getSecond() {
        return list.get(1);
    }
    
    public T getThird() {
        return list.get(2);
    }

    public boolean isHomogeneous() {
        return comp.compare(getFirst(), getSecond()) == 0
            && comp.compare(getFirst(), getThird()) == 0
            && comp.compare(getSecond(), getThird()) == 0;
    }
    
    public String toString() {
        return list.stream().map(T::toString).collect(Collectors.joining("\n"));
    }
}

使用示例：

让我们考虑按降序存储整数值。Triple

public static void main(String[] args) {
    Triple<Integer> intTriple = Triple.getInstance(5, 3, 12, Comparator.reverseOrder());

    System.out.println(intTriple);
}

输出：

12
5
3

上一个：插入排序比较分析

下一个：比较两个数据帧中的某些列名

Java 比较三个通用元素

Java Comparing three generic elements

评论