Fatal编程技术网
  • java/
  • Java 将不同类型的对象与可比对象进行比较

Java 将不同类型的对象与可比对象进行比较

java list collections

Java 将不同类型的对象与可比对象进行比较,java,list,collections,comparable,Java,List,Collections,Comparable,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(Str

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

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

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

    }

}

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

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

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

    }

}

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

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

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

    }

}
怎么办？其他的逻辑也行吗

我想做的是有一个a和B的列表，其中一个属性与id相同；虽然变量名不同。i、 e
A中的
id
和B中的
bid
。
现在我将这两个列表放在ListAll中，并在同一个变量id/bid上对它们进行排序。
我有A和B

我的listAll是Object类型的

我该怎么做？

谢谢。
我不相信在您告诉的地方会出现异常，而是在调用
sort（）

不管怎样，它的意思是

“排序方法需要实现可比较的元素的
列表
。但您告诉他您正在提供一个
对象的列表
，并且并非所有对象都实现可比较。因此，编译器无法确保列表中传递的对象实时实现可比较（根据需要）。”，并抛出一个错误“

解决方案是什么？使用实现可比较的绑定类定义列表


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



List listAll=new ArrayList（）；


更新：要使所有项目都位于同一列表中，请执行以下操作之一：

a） 使所有项都从实现
可比较的
的公共类/接口派生。通常，这是最适合面向对象编程的方法，因为如果要比较这两个类，它们必须以某种方式相关。或者从A扩展B，从B扩展A，从另一个类扩展A和B，或者使A和B实现另一个接口（其本身实现了可比较的接口）

b） 正如JBNizet所说，使用
比较器


同样，我强烈建议使用a解决方案。
我不认为在您告诉的地方会出现异常，而是在调用
sort（）

不管怎样，它的意思是

“排序方法需要实现可比较的元素的
列表
。但您告诉他您正在提供一个
对象的列表
，并且并非所有对象都实现可比较。因此，编译器无法确保列表中传递的对象实时实现可比较（根据需要）。”，并抛出一个错误“

解决方案是什么？使用实现可比较的绑定类定义列表


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



List listAll=new ArrayList（）；


更新：要使所有项目都位于同一列表中，请执行以下操作之一：

a） 使所有项都从实现
可比较的
的公共类/接口派生。通常，这是最适合面向对象编程的方法，因为如果要比较这两个类，它们必须以某种方式相关。或者从A扩展B，从B扩展A，从另一个类扩展A和B，或者使A和B实现另一个接口（其本身实现了可比较的接口）

b） 正如JBNizet所说，使用
比较器


同样，我强烈建议使用a解决方案。
要对列表进行排序，其元素必须相互比较。这里不是这样。A的实例只能与A的其他实例进行比较。B也是如此

如果要对包含a和B实例的列表进行排序，则需要提供
Comparator
，它将愉快地接受两个
a
s、两个
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");
        }
    }
}



公共类AOrBComparator实现Comparator{
@凌驾
公共整数比较（对象o1、对象o2）{
字符串o1Id=getId（o1）；
字符串o2Id=getId（o2）；
返回o1Id.compareTo（o2Id）；
}
私有字符串getId（对象o）{
如果（A的o实例）{
return（（A）o.getId（）；
}
else if（B的o实例）{
return（（B）o.getId（）；
}
否则{
抛出新的IllegalArgumentException（“只能从A或B获取ID”）；
}
}
}



但是也许A和B应该实现相同的可识别接口，并且列表应该是A
list
。通过这种方式，您可以轻松编写一个比较器来比较两个可识别的实例，无论实际实例是a、B还是任何其他可识别的实例，比较器都可以工作。
要对列表进行排序，其元素必须彼此可比。这里不是这样。A的实例只能与A的其他实例进行比较。B也是如此

如果要对包含a和B实例的列表进行排序，则需要提供
Comparator
，它将愉快地接受两个
a
s、两个
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");
        }
    }
}



公共类AOrBComparator实现Comparator{
@凌驾
公共整数比较（对象o1、对象o2）{
字符串o1Id=getId（o1）；
字符串o2Id=getId（o2）；
返回o1Id.compareTo（o2Id）；
}
私有字符串getId（对象o）{
如果（A的o实例）{
return（（A）o.getId（）；
}
else if（B的o实例）{
return（（B）o.getId（）；
}
否则{
抛出新的IllegalArgumentException（“只能从A或B获取ID”）；
}
}
}



但是也许A和B应该实现相同的可识别接口，并且列表应该是A
list
。通过这种方式，您可以轻松编写一个比较器来比较两个可识别实例，无论实际实例是a、B还是任何其他可识别实例，比较器都可以工作。
您可以添加一个公共基类并在其中实现比较，如中所示：


abstract class AandBComparable implements Comparable {

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

  public abstract String getId();
}



您可以添加一个公共基类并在其中实现比较，如中所示：


abstract class AandBComparable implements Comparable {

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

  public abstract String getId();
}


您需要一个基本（虚拟）类，它将实现
compariable
，并让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>();



List listAll=new ArrayList（）；

您需要