Java 如何对集合中的两个不同对象进行排序？

假设我有两个类CLassA和CLassB。它们有一个共同点，例如每个类包含的元素数量

如何从ClassA和CLassB的对象创建一个集合，并按该属性排序（降序的升序，无关紧要）

我创建了一个类型集合，但当我尝试实现可比较的接口时，我无法访问该方法（例如，返回元素nr的get）

我有什么解决办法

---

谢谢你的帮助

您可以创建一个自定义java.util.Comparator并使用该方法进行排序。

实际上，ClassA和ClassB应该通过继承层次结构进行关联，或者如果要将它们放在同一个集合中，则应该通过公共接口进行关联

---

最简单的方法是使用一个公共接口，为公共属性提供访问器方法。然后比较器可以使用该方法（通过接口）从ClassA的实例和ClassB的实例中获取值。

Hmm。。ClassA和ClassB是否可以共享一个接口

interface InterfaceZ
{
    int getCount();
}

class ClassA implements InterfaceZ
{
    int getCount() { return _myArray.length; }
}
class ClassB implements InterfaceZ
{
    int getCount() { return _complexCollection.size(); }
}

然后对列表进行如下排序：

List<InterfaceZ> myArray;

... fill up array ...

Collections.sort(myArray, new Comparator<InterfaceZ>() {
public int compare(InterfaceZ o1, InterfaceZ o2) {
    return o2.getCount() - o1.getCount();
}});

列出myArray；
... 填充数组。。。
Collections.sort（myArray，newcomparator（）{
公共整数比较（InterfaceZ o1，InterfaceZ o2）{
返回o2.getCount（）-o1.getCount（）；
}});

如果您有权访问CLassA和~B的声明，则使用公共接口，如果没有，则可以为这两个类编写包装器：

根据描述，我定义了自己的类~A和~B，以便进行测试。假设它们是外来源，您就可以访问这些类

import java.util.*;

public class SortAB
{
    class CLassA {
        int [] elements;
        public CLassA (int [] a) {elements = a;}
        public int getElementCount () {return elements.length;}
    }

    class CLassB {
        List <Integer> elements;
        public CLassB (List <Integer> l) {elements = l;}
        public int getElementCount () {return elements.size ();}
    }

    /** a common element-count-wrapper with compareTo method */     
    abstract class EcWrapper <T> implements Comparable <EcWrapper> {
        public abstract int getElementCount ();
        public int compareTo (EcWrapper o) {return getElementCount () - o.getElementCount ();}
    }
    /** concrete Wrapper for CLassA */
    class EcAWrapper extends EcWrapper <CLassA> {
        private CLassA inner;
        public EcAWrapper (CLassA t) {
            inner = t;
        }
        public int getElementCount () {return inner.getElementCount (); }
    }
    /** concrete Wrapper for CLassB */
    class EcBWrapper extends EcWrapper <CLassB> {
        private CLassB inner;
        public EcBWrapper (CLassB t) {
            inner = t;
        }
        public int getElementCount () {return inner.getElementCount (); }
    }

    // testing
    public SortAB ()
    {
        int [] ia = {3, 5, 7, 6, 9, 11, 14}; 
        List <Integer> il = new ArrayList <Integer> (); 
        for (int i: ia) 
            il.add (i); 
        il.add (15);
        il.add (16);

        CLassA a = new CLassA (ia);
        CLassB b = new CLassB (il);
        List <EcWrapper> list = new ArrayList <EcWrapper> ();
        list.add (new EcBWrapper (b));
        list.add (new EcAWrapper (a));
        show (list);
        Collections.sort (list);
        show (list);
    }

    public static void main (String args[])
    {
        new SortAB ();
    }

    public static void show (List <EcWrapper> list)
    {
        for (EcWrapper e: list) 
            System.out.println ("\t" + e.getElementCount ());
        System.out.println ("---");
    }
}

import java.util.*；
公共类分类表
{
甲级{
int[]元素；
公共类a（int[]a）{elements=a；}
public int getElementCount（）{return elements.length；}
}
B类{
列出要素；
公共类B（列表l）{elements=l；}
public int getElementCount（）{return elements.size（）；}
}
/**带有compareTo方法的公共元素计数包装器*/
抽象类EcWrapper实现了可比较的{
公共抽象int getElementCount（）；
public int compareTo（ECO）{return getElementCount（）-o.getElementCount（）；}
}
/**A类混凝土包装材料*/
类EcAWrapper扩展了EcWrapper{
私家甲级内；
公共设施（A类和t类）{
内=t；
}
public int getElementCount（）{return inner.getElementCount（）；}
}
/**B类混凝土包装*/
类EcBWrapper扩展了EcWrapper{
私有B类内部；
公共电子断路器（B类和t类）{
内=t；
}
public int getElementCount（）{return inner.getElementCount（）；}
}
//测试
公共排序表（）
{
int[]ia={3,5,7,6,9,11,14}；
List il=new ArrayList（）；
对于（int i:ia）
il.add（i）；
il.add（15）；
il.add（16）；
a类=新的a类（ia）；
b类=新b类（il）；
List=newarraylist（）；
list.add（新EcBWrapper（b））；
list.add（新名称（a））；
显示（列表）；
Collections.sort（列表）；
显示（列表）；
}
公共静态void main（字符串参数[]）
{
新的SortAB（）；
}
公共静态无效显示（列表）
{
for（ece:list）
System.out.println（“\t”+e.getElementCount（））；
System.out.println（“--”）；
}
}

如果您可以声明这两个类来实现为公共属性声明公共访问器方法的接口，那么编写比较器可能会有所帮助。我认为这是我最好的选择。在OO范式中，如果这些类有共同点，那么它们必须是相关的。感谢sugestionIt的帮助这是一个很好的解决方案，但我确实有权声明类。我会选择界面。非常感谢。