比较不同类型的具有可比性的对象(Comparing different type of Object

A.java

public class A implements Comparable {
    private String id;
    private String name;

    public A(String a, String b) {
        id = a;
        name = b;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int compareTo(Object o) {
        A a = (A) o;
        return id.compareTo(a.getId());
    }
}

B.java

public class B implements Comparable {
    private String b_id;
    private String other;

    public B(String a, String b) {
        b_id = a;
        other = b;
    }

    public String getBId() {
        return b_id;
    }

    public void setBId(String id) {
        this.b_id = id;
    }

    public String getOther() {
        return other;
    }

    public void setOther(String other) {
        this.other = other;
    }

    public int compareTo(Object o) {
        B b = (B) o;
        return b_id.compareTo(b.getId());
    }
}

Learn.java

public class Learn {

    public static void main(String[] args) {

        List<A> listA = new ArrayList<A>();
        List<B> listB = new ArrayList<B>();
        List<Object> listAll = new ArrayList<Object>();
        listA.add(new A("aa", "bb"));
        listA.add(new A("ae", "bbn"));
        listA.add(new A("dfr", "GSDS"));
        listB.add(new B("nm", "re"));
        listB.add(new B("asd", "asfa"));

        listAll.addAll(listA);
        listAll.addAll(listB);
        Collections.sort(listAll);
        for (Object o : listAll) {
            if (o instanceof A)
                System.out.println(o.getId);
            else if (o instanceof B)
                Syatem.out.println(o.getBId);
        }

    }

}

我得到的错误是在该行Collections.sort(listAll); 它说。

Bound mismatch: The generic method sort(List<T>) of type Collections is not applicable
for the arguments (List<Object>). The inferred type Object is not a valid substitute
for the bounded parameter <T extends Comparable<? super T>>

该怎么办？ 也就是逻辑的休息好吗？

我所试图做的是有B的名单，并列出一个属性相同ID; 虽然变量名是不一样的。 即id在A和bid中B.现在我把两个列表中ListAll做排序上他们在同一个变量ID /投标。 我有A和B实现媲美。

我listAll是Object类型的？

我该怎么做？ 谢谢。

Answer 1:

你可以添加一个共同的基类，并实现比较有，如：

abstract class AandBComparable implements Comparable {

  public int compareTo(Object o) {
    AandBComparable ab = (AandBComparable) o;
    return getId().compareTo(ab.getId());
  }

  public abstract String getId();
}

Answer 2:

为了能够排序列表，它的元素必须是相互媲美。 这不是这里的情况。 A的情况下，只能与同为B. A的其他实例相比

如果要排序的列表方含A和B的情况下，你需要提供Comparator这会很乐意采取两种A S，2 B S或一个A和B ，正如你希望他们相比，这些对象进行比较。

public class AOrBComparator implements Comparator<Object> {
    @Override
    public int compare(Object o1, Object o2) {
        String o1Id = getId(o1);
        String o2Id = getId(o2);
        return o1Id.compareTo(o2Id);
    }

    private String getId(Object o) {
        if (o instanceof A) {
            return ((A) o).getId();
        }
        else if (o instanceof B) {
            return ((B) o).getId();
        }
        else {
            throw new IllegalArgumentException("Can only get ID from A or B");
        }
    }
}

但也许A和B应该实现相同的可识别接口，并且该列表应该是一个List<Identifiable> 。 通过这种方式，你可以很容易地编写一个比较可识别的两个实例比较，它会工作的实际情况是A，B，或任何其它身份。

Answer 3:

我不相信异常升高，你知道的，而是在调用sort()

无论如何，这意味着像

“排序方法需要一个List实现可比的元素。但是，你告诉他，你是给列表Object ，而不是所有的目标实现具有可比性 。因此，编译器不能确保在实时的对象列表中通过将实现可比性（如需要），并抛出一个错误”

解决方案？ 以实现可比绑定类定义列表

 List<A> listAll = new ArrayList<A>(); 

更新：要在同一个列表中的所有项目，那么：

a）拥有所有项目从一个共同的类/接口实现派生Comparable 。 通常这会是面向对象的编程友好的方式最对象，因为如果你想他们必须以某种方式与这两个类比较。 无论是从B，A和B从另一个类延伸从A B，A，或使A和B实现的另一个接口（其本身实现可比）。

b）作为所述JBNizet，使用Comparator 。

同样，我强烈建议您使用的解决方案。

Answer 4:

你需要一个基地（虚拟）类将实现Comparable ，让A和B类派生。 就像是：

public abstract class MyComparableClass implements Comparable {
}

public class A extends MyComparableClass {
... // implementation of compareTo
}

public class B extends MyComparableClass {
...// implementation of compareTo
}

在你的主程序，然后简单地定义集合为：

List<MyComparableClass> listAll = new ArrayList<MyComparableClass>();

文章来源: Comparing different type of Objects with comparable