Cómo ordenar correctamente en Java

Al analizar el código fuente de muchos proyectos Java de código abierto, descubrí que la mayoría de los desarrolladores implementan la clasificación solo de dos maneras diferentes. Uno de ellos se basa en el uso del método sort()de clase Collectionso Arrays, y el otro se basa en el uso de estructuras de datos autoclasificadas como TreeMapy TreeSet.

Usando el método sort()

Si necesita ordenar una colección, utilice el archivo Collections.sort().

// Collections.sort(…)
List<ObjectName> list = new ArrayList<ObjectName>();
Collections.sort(list, new Comparator<ObjectName>() {
	public int compare(ObjectName o1, ObjectName o2) {
		return o1.toString().compareTo(o2.toString());
	}
});

Si necesita ordenar una matriz, utilice el archivo Arrays.sort().

// Arrays.sort(…)
ObjectName[] arr = new ObjectName[10];
Arrays.sort(arr, new Comparator<ObjectName>() {
	public int compare(ObjectName o1, ObjectName o2) {
		return o1.toString().compareTo(o2.toString());
	}
});

El método sort()es muy conveniente cuando la colección o matriz ya está llena de valores.

Usar estructuras de datos de autoclasificación

Si necesita ordenar una lista ( List) o un conjunto ( Set), utilice una TreeSetestructura de clasificación.

// TreeSet
Set<ObjectName> sortedSet = new TreeSet<ObjectName>(new Comparator<ObjectName>() {
	public int compare(ObjectName o1, ObjectName o2) {
		return o1.toString().compareTo(o2.toString());
	}
});
sortedSet.addAll(unsortedSet);

Si necesita ordenar un diccionario ( Map), utilice una TreeMapestructura de clasificación. TreeMapordenados por clave ( key).

// TreeMap – использующий String ключи и компаратор (Comparator) CASE_INSENSITIVE_ORDER,
// упорядочивающий строки (String) методом compareToIgnoreCase
Map<String, Integer> sortedMap = new TreeMap<String, Integer>(String.CASE_INSENSITIVE_ORDER);
sortedMap.putAll(unsortedMap);

//TreeMap – общий случай, компаратор указывается вручную
Map<ObjectName, String> sortedMap = new TreeMap<ObjectName, String>(new Comparator<ObjectName>() {
	public int compare(ObjectName o1, ObjectName o2) {
		return o1.toString().compareTo(o2.toString());
	}
});
sortedMap.putAll(unsortedMap);

El enfoque anterior es muy útil en los casos en los que necesita realizar una gran cantidad de búsquedas de elementos en una colección. Las estructuras de datos de clasificación automática tienen una eficiencia O(log(n))mejor que O(n). Esto significa que cuando se duplica la cantidad de datos de la colección, el tiempo de búsqueda no se duplica, sino que aumenta en una cantidad constante .

Mal enfoque para el problema de clasificación.

Todavía puede encontrar ejemplos en los que los programadores describen de forma independiente algoritmos de clasificación. Considere el código de clasificación que se presenta a continuación (clasificar una matriz doble en orden ascendente ). Este código no sólo es ineficiente, sino también ilegible. Y hay muchos ejemplos de este tipo.

double t;
for (int i = 0; i < N; i++)
	for (int j = i + 1; j < N; j++)
		if (r[j] < r[i]) {
			t = r[i];
			r[i] = r[j];
			r[j] = t;
		}