Al analizar el código fuente de una gran cantidad de proyectos Java de código abierto, encontré que los desarrolladores de Java clasifican con frecuencia de dos maneras. Uno está usando el sort() método de Collections o Arraysy el otro utiliza estructuras de datos ordenadas, como TreeMap y TreeSet.
1. Usando el método sort ()
Si es una colección, use el método 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());
}
});
|
// Collections.sort List list = new ArrayList (); Collections.sort (lista, nuevo Comparador () {public int compare (ObjectName o1, ObjectName o2) {return o1.toString (). CompareTo (o2.toString ());}});
Si es una matriz, use Arrays.sort() método.
// 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());
}
});
|
// Arrays.sort ObjectName[] arr = nuevo ObjectName[10]; Arrays.sort (arr, new Comparator () {public int compare (ObjectName o1, ObjectName o2) {return o1.toString (). CompareTo (o2.toString ());}});
Esto es muy conveniente si ya se ha configurado una colección o una matriz.
2. Uso de estructuras de datos ordenadas
Si es una lista o conjunto, use TreeSet para ordenar.
// 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);
|
// TreeSet Set sortedSet = new TreeSet (new Comparator () {public int compare (ObjectName o1, ObjectName o2) {return o1.toString (). CompareTo (o2.toString ()); }}); sortedSet.addAll (unsortedSet);
Si es un mapa, use TreeMap para ordenar. TreeMap está ordenado por clave.
// TreeMap - using String.CASE_INSENSITIVE_ORDER which is a Comparator that orders Strings by compareToIgnoreCase
Map<String, Integer> sortedMap = new TreeMap<String, Integer>(String.CASE_INSENSITIVE_ORDER);
sortedMap.putAll(unsortedMap);
|
// TreeMap – usando String.CASE_INSENSITIVE_ORDER que es un comparador que ordena cadenas por compareToIgnoreCase Map sortedMap = new TreeMap (String.CASE_INSENSITIVE_ORDER); sortedMap.putAll (unsortedMap);
//TreeMap - In general, defined comparator
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);
|
// TreeMap – En general, mapa comparador definido sortedMap = new TreeMap (new Comparator () {public int compare (ObjectName o1, ObjectName o2) {return o1.toString () .compareTo (o2.toString ());}}); sortedMap.putAll (unsortedMap);
Este enfoque es muy útil, si desea realizar muchas operaciones de búsqueda para la colección. La estructura de datos ordenados dará una complejidad de tiempo de O(logn), que es menor que O(n).
3. Malas prácticas
Todavía existen malas prácticas, como el uso de algoritmos de clasificación autodefinidos. Tome el siguiente código, por ejemplo, no solo el algoritmo no es eficiente, sino que tampoco es legible. Esto sucede mucho en diferentes formas de variaciones.
double t;
for (int i = 0; i < 2; i++)
for (int j = i + 1; j < 3; j++)
if (r[j] < r[i]) {
t = r[i];
r[i] = r[j];
r[j] = t;
}
|
doble t; para (int i = 0; i <2; i ++) para (int j = i + 1; j <3; j ++) si (r[j]
