Cómo obtener la lista del conjunto y el comparador

Question

¿Cuál es la solución "buena" (y ¿por qué?) Para obtener un List de un Set y ordenada en un Comparator dado?

Answer 1

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

// add stuff 

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

Answer 2

Solo protégelo. El ArrayList tiene 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

Esta es la forma de conseguir un List cuando se tiene un Set:

List list = new ArrayList(set); 

No está seguro de lo que se espera que ver con la Comparator. Si el Set está ordenado, la lista contendrá los elementos en orden ordenado.

Answer 4

O bien:

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

Suponiendo que se inicia con un conjunto sin ordenar o un conjunto ordenado en un orden diferente, la siguiente es probablemente el asumir más eficiente que necesita una Lista modificable.

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

Si una lista no modificable es aceptable, entonces el siguiente es un poco más rápido:

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

En la primera versión, Collections.sort(...) copias la lista de contenidos a una matriz, ordena la matriz, y copia los elementos ordenados volver a la lista. La segunda versión es más rápida porque no necesita copiar los elementos ordenados.

Pero para ser sincero, la diferencia de rendimiento probablemente no sea significativa. De hecho, a medida que los tamaños de los conjuntos de entrada se hacen más grandes, el rendimiento estará dominado por el tiempo O(NlogN) para hacer la clasificación. Los pasos de copia son O(N) y su importancia va disminuyendo a medida que N crece.