Come ottenere l'elenco da Set e Comparatore

Question

Qual è la soluzione "buona" (e perché?) Per ottenere uno List da un Set e ordinato rispetto a un dato Comparator?

Answer 1

Set<Object> set = new HashSet<Object>(); 

// add stuff 

List<Object> list = new ArrayList<Object>(set); 
Collections.sort(list, new MyComparator()); 

Answer 2

Costruirlo. Il ArrayList ha un constructor taking another Collection.

Set<Foo> set = new TreeSet<Foo>(new FooComparator<Foo>()); 
// Fill it. 

List<Foo> list = new ArrayList<Foo>(set); 
// Here's your list with items in the same order as the original set. 

Answer 3

Questo è come ottenere un List quando si ha un Set:

List list = new ArrayList(set); 

Non sei sicuro di quello che ci si aspetta di fare con il Comparator. Se lo Set è ordinato, l'elenco conterrà gli elementi ordinati.

Answer 4

O:

Set<X> sortedSet = new TreeSet<X>(comparator); ... 
List<X> list = new ArrayList<X>(sortedSet); 

o:

Set<X> unsortedSet = new HashSet<X>(); ... 
List<X> list = new ArrayList<X>(unsortedSet); 
Collections.sort(list, comparator); 

Answer 5

Supponendo che si avvia con un insieme non ordinato o un set ordinato in un ordine diverso, il seguente è probabilmente la assumendo più efficiente che hai bisogno di una lista modificabile.

Set<T> unsortedSet = ... 
List<T> list = new ArrayList<T>(unsortedSet); 
Collections.sort(list, comparator); 

Se un elenco non modificabile è accettabile, allora il seguente è un po 'più veloce:

Set<T> unsortedSet = ... 
T[] array = new T[unsortedSet.size()]; 
unsortedSet.toArray(array); 
Arrays.sort(array, comparator); 
List<T> list = Arrays.asList(array); 

Nella prima versione, Collections.sort(...) Copia l'elenco contenuto a un array, ordina l'array e copia i elementi ordinati di nuovo alla lista. La seconda versione è più veloce perché non ha bisogno di copiare gli elementi ordinati.

Ma a dire il vero la differenza di prestazioni non è probabilmente significativa. Infatti, man mano che le dimensioni del set di input aumentano, le prestazioni saranno dominate dal tempo O(NlogN) per eseguire l'ordinamento. I passaggi di copia sono O(N) e ridurranno di importanza man mano che N cresce.