比较 Java 中的可比对象数组答案

【问题标题】：Comparing an Array of Comparables in Java比较 Java 中的可比对象数组
【发布时间】：2011-04-22 18:39:08
【问题描述】：

我想比较一组可比对象。最简单的方法似乎如下（细节未显示）：

public class ArrayComparable implements Comparable<ArrayComparable>{
ArrayList<Comparable<?>> list = new ArrayList<Comparable<?>>();

@Override
public int compareTo(ArrayComparable ac) {
    Iterator<Comparable<?>> itr = ac.list.iterator();
    for(Comparable<?> l : list) {
        Comparable<?> itrNext = itr.next();
        if(itrNext.getClass() == l.getClass()) {
            if(itrNext.compareTo(l)) {
                //something
            } else {
                //other stuff
            }
        } else {
            //some other thing
        }
    }
}

当然，这里的问题是compareTo 中的itrNext.compareTo(l) 将无法工作，给出错误：The method compareTo(capture#6-of ?) in the type Comparable<capture#6-of ?> is not applicable for the arguments (Comparable<capture#7-of ?>) 我明白为什么（就方法而言，我可能会将苹果与橙子进行比较）。另一方面，我知道我不是在比较之前检查事物的类别。

那么有什么方法可以让我完成这项工作吗？不要担心比较任何可比数组的合理性，因为我有充分的理由要这样做。

编辑-那么我为什么要做这样的事情。假设我想要一个可比较的数组，我不在乎每个索引中包含什么，只要类型对应，并且可以进行比较。然后我可以在这些数组之间进行一般的字典比较。这样我就不必为(int,int) 和(int, string) 和(string, double, string) 或任何你需要的东西写一个可比的。我只写了一个，只要确保类型匹配（并且可以），我就可以开始了。

【问题讨论】：

“另一方面，我知道我不是，因为我在比较之前检查了事物的类别。”所以？仅仅因为两个对象属于同一类并不意味着您可以比较它们。

标签： java arrays generics compareto

【解决方案1】：

在您当前使用Comparable<?> 的任何地方使用原始类型Comparable 应该可以工作。实际上，如果你愿意，你可以在一个地方这样做：

if (((Comparable) itrNext).compareTo(l) == 0)

【讨论】：

去掉模板确实有效。太糟糕了，我需要忍受警告。我想要的并不是那么不合理。但我想这将是要走的路。
@delmet：在方法中添加@SuppressWarnings("unchecked")，并附上注释，解释为什么这样做应该是安全的。

【解决方案2】：

使ArrayComparable 成为泛型类，这样您就可以正确地参数化泛型，而不是到处使用<?>。哦，你也可以实现Iterable。

public class ArrayComparable<T> implements Comparable<ArrayComparable<T>>, Iterable<T>
{
    List<Comparable<T>> list = new ArrayList<Comparable<T>>();

    @Override
    public int compareTo(ArrayComparable<T> ac)
    {
        // snip
    }

    @Override
    public Iterator<T> iterator()
    {
        return list.iterator();
    }
}

【讨论】：

我认为这个类（以及扩展的List）包含任何类型的Comparables，而不仅仅是特定类型的T。
我怀疑 OP 希望数组包含不同的可比较对象，而不仅仅是一种类型（即他很疯狂，但他知道）
如果是这样，那么ew。 ...哦，嘿，克劳迪乌！
是的，我完全意识到自己的精神错乱。但是有些应用程序需要这种东西。这个特别的来自 hadoop。
您应该限制<T extends Comparable<? super T>> 以确保T 与自身具有可比性

【解决方案3】：

试试这个：

    if(itrNext.getClass().cast(itrNext).compareTo(l.getClass().cast(l))) {
        //something
    } else {
        //other stuff
    }

【讨论】：

【解决方案4】：

public class GenericDemo<T>{
  T g;
 public <T extends Comparable<T>> void printData(T a[]){
    T max = a[0];
    if(a[1].compareTo(max)>0){
        max=a[1];
    }
    if(a[2].compareTo(max)>0){
    max=a[1];
    }
    System.out.println(max);
    System.out.println("DataType: " +a.getClass().getName());

      }
    public static void main(String[] ar)
    {
     Integer a[]={1,2,3};
     Byte b[]= {4,6,7};
     Short c[]={6,8,9};

     GenericDemo g = new GenericDemo();
     g.printData(a);
     g.printData(b);
     g.printData(c);
     } 
}

【讨论】：

【解决方案5】：

一个很好的答案是：

public final class ArrayComparable<T extends Comparable<T>>
    implements Comparable<ArrayComparable<T>> {

    private final ArrayList<T> list = new ArrayList<>();

    @Override
    public int compareTo(final ArrayComparable<T> other) {

        final Iterator<T> it = other.list.iterator();

        for (final T element : list) {
            final T otherElement = it.next();

            final int comparison = element.compareTo(otherElement);
            if (comparison < 0) {
                // something
            } else if (comparison > 0) {
                // other stuff
            } else {
                // other stuff
            }
        }
        return 0;
    }
}

【讨论】：