比较Java中的一组可比数据

我想比较一系列可比数据。最简单的方法如下（未显示详细信息）：

公共类ArrayCompable实现{
ArrayList>（）；
@凌驾
公共整数比较（ArrayComparable ac）{
迭代器itrNext=itr.next（）；
如果（itrNext.getClass（）==l.getClass（））{
如果（itrNext.与（l）相比）{
//某物
}否则{
//其他东西
}
}否则{
//还有别的事
}
}
}

当然，这里的问题是

compareTo

与

itrNext.compareTo（l）

一样，如果给出错误：

类型compareTo（capture#6-Of？）中的方法compareTo不适用于参数（Comparable）

---

我明白为什么（就方法而言，我可能是在比较苹果和桔子）。另一方面，我知道我不是，因为我在比较之前检查了事物的类别

有没有办法让这一切顺利进行？不要担心比较任何可比较的数组是否明智，因为我有一个很好的理由要这样做

---

编辑-那我为什么要这样做呢。比如说，我想要一系列可比较的数据，我不在乎每个索引中包含什么，只要类型对应，并且可以进行比较。然后我可以在这些数组之间进行一般的词典比较。这样，我就不必为

（int，int）

和

（int，string）

，以及

（string，double，string）

或任何您需要的东西编写类似的代码。我只写了一个，只要我确保类型匹配（而且我可以），我就可以开始了。

将

arraycompatable

设置为泛型类，这样您就可以正确地参数化泛型，而不是到处使用

。哦，您还可以实现

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

公共类ArrayCompable实现可比较、可编辑
{
列表=新的ArrayList（）；
@凌驾
公共整数比较（ArrayComparable ac）
{
//剪断
}
@凌驾
公共迭代器迭代器（）
{
return list.iterator（）；
}
}

试试这个：

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

---

使用原始类型

Comparable

，无论您当前在何处使用

Comparable

，都应该有效。实际上，如果你愿意，你可以在一个地方做：

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

公共类GenericDemo{
tg；
公共作废打印数据（T a[]{
T max=a[0]；
如果（a[1]。比较到（max）>0）{
max=a[1]；
}
如果（a[2]。比较到（max）>0）{
max=a[1]；
}
系统输出打印项次（最大值）；
System.out.println（“数据类型：+a.getClass（）.getName（））；
}
公共静态void main（字符串[]ar）
{
整数a[]={1,2,3}；
字节b[]={4,6,7}；
短c[]={6,8,9}；
GenericDemo g=新的GenericDemo（）；
g、 印刷数据（a）；
g、 印刷数据（b）；
g、 印刷数据（c）；
} 
}

对此的一个好答案是：

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

公共最终类数组可比较
实现可比性{
private final ArrayList list=new ArrayList（）；
@凌驾
公共整数比较（最终阵列可比其他）{
final Iterator it=other.list.Iterator（）；
对于（最终T元素：列表）{
final T otherElement=it.next（）；
最终整数比较=元素。比较到（其他元素）；
如果（比较<0）{
//某物
}否则如果（比较>0）{
//其他东西
}否则{
//其他东西
}
}
返回0；
}
}

我认为这个类（以及扩展的

列表）包含任何类型的
可比的
s，而不仅仅是特定类型的
T
。我怀疑OP希望数组包含不同的可比性，而不仅仅是一种类型的（即他疯了，但他知道），如果是这样的话，那么ew。。。哦，嘿，克劳迪乌！是的，我完全意识到我的疯狂。但有些应用程序需要这种东西。这个特别的模板来自hadoop。你应该限制
模板确实有效。很遗憾，我需要接受警告。我想要的并不是那么不合理。但我想这将是一条路。@delmet:在方法中添加一个
@SuppressWarnings（“unchecked”）
，并添加一条注释，解释为什么这样做应该是安全的。“另一方面，我知道我不是，因为我在比较之前检查了这类事物。”那么？仅仅因为两个对象是同一个类并不意味着可以比较它们。
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);
     } 
}

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