如何對集合中的兩個不同對象進行排序？

Question

假設我有兩個類CLassA和CLassB。他們有一個共同點，例如每個班級擁有的元素數量。

如何從ClassA和CLassB的對象創建集合並按該屬性進行排序（降序升序無關緊要）？

我做了一個類型的集合，但是當我嘗試實現可比較接口時，我無法訪問該方法（例如get返回元素的nr）。

我有什麼解決方案？

感謝您的幫助！

Answer 1

真正的ClassA和ClassB應該通過繼承層次結構相關，或者如果你打算把它們放在同一個集合中，通過一個通用接口相關。

最簡單的事情就是擁有一個通用接口，爲通用屬性提供訪問方法。然後比較器可以使用該方法（通過接口）從ClassA的實例以及ClassB的實例中獲取值。

Answer 2

您可以創建一個自定義java.util.Comparator並使用Collections.sort(List list, Comparator c)方法進行排序。

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