Question

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

怎么办？其余的逻辑还可以吗？

我要做的是有一个A列表和一个B列表，其中一个属性与id相同;虽然变量名称不一样。即id中的A和B中的bid 现在我将这两个列表放在ListAll中，并在相同的变量id / bid上对它们进行排序。我有A和B实现Comparable。

我的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的实例只能与A的其他实例进行比较。对于B.

如果要对包含A和B实例的列表进行排序，则需要提供Comparator，这将很乐意花费两个A，两个B或{{1}和A，并比较这些对象，因为你想要比较它们。

但也许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"); } } }。通过这种方式，您可以轻松编写比较两个Identifiable实例的比较器，无论实际实例是A，B还是任何其他可识别实体，它都可以工作。

Answer 3

我不相信这个例外会引发你所说的，而是在调用sort()

无论如何，它意味着类似

“排序方法需要List个实现可比较的元素。但是你告诉他你列出的是Object，而并非所有的Object都实现了Comparable 那么，编译器无法确定实时列表中传递的对象是否会实现Comparable（根据需要），并抛出错误“

解决方案？使用实现Comparable

的绑定类定义列表

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

更新：要将所有项目放在同一个列表中，请：

a）让所有项都来自实现Comparable的公共类/接口。通常这将是最面向对象编程的友好方法，因为如果你想比较两个类，它们必须以某种方式相关。从A扩展B，从B扩展A，从另一个类扩展A和B，或者使A和B实现另一个接口（它本身实现Comparable）。

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
}

在主程序中，只需将Collection定义为：

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

比较不同类型的物体具有可比性

4 个答案: