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

Question

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

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

我创建了一个类型的集合，但是当我尝试实现 Comparable Interface 时，我无法访问该方法（例如，返回 nr 元素的 get ）。

我有什么解决方案？

谢谢你的帮助！

Answer 1

您可以制作自定义 java.util.Comparator 并使用Collections.sort(List list, Comparator c)方法进行排序。

Answer 2

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

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

Answer 3

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

Answer 4

如果您可以访问 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 ("---");
    }
}