(desde Formas de ordenar listas de objetos en Java en función de múltiples campos )
Código de trabajo en esta esencia
Uso de Java 8 lambda (agregado el 10 de abril de 2019)
Java 8 resuelve esto muy bien por lambda (aunque Guava y Apache Commons aún podrían ofrecer más flexibilidad):
Collections.sort(reportList, Comparator.comparing(Report::getReportKey)
.thenComparing(Report::getStudentNumber)
.thenComparing(Report::getSchool));
Gracias a la respuesta de @ gaoagong a continuación .
Desordenado y complicado: ordenar a mano
Collections.sort(pizzas, new Comparator<Pizza>() {
@Override
public int compare(Pizza p1, Pizza p2) {
int sizeCmp = p1.size.compareTo(p2.size);
if (sizeCmp != 0) {
return sizeCmp;
}
int nrOfToppingsCmp = p1.nrOfToppings.compareTo(p2.nrOfToppings);
if (nrOfToppingsCmp != 0) {
return nrOfToppingsCmp;
}
return p1.name.compareTo(p2.name);
}
});
Esto requiere mucho tipeo, mantenimiento y es propenso a errores.
La forma reflexiva: ordenar con BeanComparator
ComparatorChain chain = new ComparatorChain(Arrays.asList(
new BeanComparator("size"),
new BeanComparator("nrOfToppings"),
new BeanComparator("name")));
Collections.sort(pizzas, chain);
Obviamente, esto es más conciso, pero aún más propenso a errores, ya que pierde su referencia directa a los campos mediante el uso de cadenas (sin seguridad de tipografía, refactorizaciones automáticas). Ahora, si se cambia el nombre de un campo, el compilador ni siquiera informará un problema. Además, debido a que esta solución utiliza la reflexión, la clasificación es mucho más lenta.
Cómo llegar: Ordenando con Google Guava's ComparisonChain
Collections.sort(pizzas, new Comparator<Pizza>() {
@Override
public int compare(Pizza p1, Pizza p2) {
return ComparisonChain.start().compare(p1.size, p2.size).compare(p1.nrOfToppings, p2.nrOfToppings).compare(p1.name, p2.name).result();
// or in case the fields can be null:
/*
return ComparisonChain.start()
.compare(p1.size, p2.size, Ordering.natural().nullsLast())
.compare(p1.nrOfToppings, p2.nrOfToppings, Ordering.natural().nullsLast())
.compare(p1.name, p2.name, Ordering.natural().nullsLast())
.result();
*/
}
});
Esto es mucho mejor, pero requiere un código de placa de caldera para el caso de uso más común: los valores nulos deben valorarse menos por defecto. Para los campos nulos, debe proporcionar una directiva adicional a Guava sobre qué hacer en ese caso. Este es un mecanismo flexible si desea hacer algo específico, pero a menudo desea el caso predeterminado (es decir, 1, a, b, z, nulo).
Ordenar con Apache Commons CompareToBuilder
Collections.sort(pizzas, new Comparator<Pizza>() {
@Override
public int compare(Pizza p1, Pizza p2) {
return new CompareToBuilder().append(p1.size, p2.size).append(p1.nrOfToppings, p2.nrOfToppings).append(p1.name, p2.name).toComparison();
}
});
Al igual que ComparisonChain de Guava, esta clase de biblioteca se clasifica fácilmente en múltiples campos, pero también define el comportamiento predeterminado para valores nulos (es decir, 1, a, b, z, nulo). Sin embargo, tampoco puede especificar nada más, a menos que proporcione su propio Comparador.
Así
En última instancia, se trata de sabor y la necesidad de flexibilidad (Guava's ComparisonChain) versus código conciso (Apache's CompareToBuilder).
Método de bonificación
Encontré una buena solución que combina múltiples comparadores en orden de prioridad en CodeReview en MultiComparator:
class MultiComparator<T> implements Comparator<T> {
private final List<Comparator<T>> comparators;
public MultiComparator(List<Comparator<? super T>> comparators) {
this.comparators = comparators;
}
public MultiComparator(Comparator<? super T>... comparators) {
this(Arrays.asList(comparators));
}
public int compare(T o1, T o2) {
for (Comparator<T> c : comparators) {
int result = c.compare(o1, o2);
if (result != 0) {
return result;
}
}
return 0;
}
public static <T> void sort(List<T> list, Comparator<? super T>... comparators) {
Collections.sort(list, new MultiComparator<T>(comparators));
}
}
Por supuesto, Apache Commons Collections ya tiene una utilidad para esto:
ComparatorUtils.chainedComparator (comparatorCollection)
Collections.sort(list, ComparatorUtils.chainedComparator(comparators));
