contrato Comparable y Comparator en lo que respecta a null

Question

Comparable contrato especifica que debe lanzar e.compareTo(null)NullPointerException.

De the API:

Tenga en cuenta que null no es una instancia de cualquier clase, y e.compareTo(null) debería lanzar una NullPointerException A pesar de que los rendimientos e.equals(null)false.

Por otro lado Comparator API, menciona nada acerca de lo que debe suceder cuando se comparan null. Considere el siguiente intento de un método genérico que toma un Comparable, y devolver una Comparator por ello que pone null como el elemento mínimo.

static <T extends Comparable<? super T>> Comparator<T> nullComparableComparator() { 
    return new Comparator<T>() { 
     @Override public int compare(T el1, T el2) { 
     return 
      el1 == null ? -1 : 
      el2 == null ? +1 : 
      el1.compareTo(el2); 
     } 
    }; 
} 

Esto nos permite hacer lo siguiente:

List<Integer> numbers = new ArrayList<Integer>(
    Arrays.asList(3, 2, 1, null, null, 0) 
); 
Comparator<Integer> numbersComp = nullComparableComparator(); 
Collections.sort(numbers, numbersComp); 
System.out.println(numbers); 
// "[null, null, 0, 1, 2, 3]" 

List<String> names = new ArrayList<String>(
    Arrays.asList("Bob", null, "Alice", "Carol") 
); 
Comparator<String> namesComp = nullComparableComparator(); 
Collections.sort(names, namesComp); 
System.out.println(names); 
// "[null, Alice, Bob, Carol]" 

Así que las preguntas son:

• Es éste un uso aceptable de un Comparator, o es violar una regla no escrita respecto comparando null y lanzando NullPointerException?
• ¿Puede ser una buena idea para tener siquiera para ordenar una List que contienen elementos null, o es que un signo seguro de un error de diseño?

Answer 1

Comparable no permite null simplemente porque:

a.compareTo(b) == -b.compareTo(a) 

para todos los objetos a y b donde !a.equals(b). Más específicamente:

a.equals(b) ? b.equals(a) && a.compareTo(b) == 0 && 
        b.compareTo(a) == 0 && a.hashCode() == b.hashCode() 
      : !b.equals(a) && a.compareTo(b) != 0 && 
        a.compareTo(b) == -b.compareTo(a) 

debe evaluar a true para satisfacer los contratos correspondientes.

Así null no está permitido porque no se puede hacer:

null.compareTo(a) 

Comparator es más flexible para la manipulación de null es un problema específico de la implementación. Apoyar o no dependiendo de lo que usted quiere que su Comparator que hacer.

Answer 2

¿Alguna vez es una buena idea incluso tener que ordenar una lista que contenga elementos nulos o es una señal segura de un error de diseño?

Conceptualmente, null significa "nada", y no colocar nada en una lista me parece extraño. Además, el contrato de la Lista Java establece que

Algunas implementaciones de listas tienen restricciones sobre los elementos que pueden contener.Por ejemplo, algunas implementaciones prohíben los elementos nulos

por lo que una implementación de lista en Java ni siquiera es necesaria para admitir elementos nulos. En resumen, si no tiene una buena razón para poner nulo en una lista, no lo haga, y si lo hace, pruebe que realmente funciona como se esperaba.

Answer 3

¿Es siempre una buena idea tener incluso a ordenar una lista que contiene elementos nulos, o es que un signo seguro de un error de diseño ?

Bueno, es probable que no tiene sentido para que la lista incluya un objeto nulo, pero tal vez su lista contiene un "objeto de negocio" y se puede clasificar en diferentes propiedades del objeto de negocio, algunos de los cuales pueden contener nulos

Es esto un uso aceptable de un comparador

El BeanComparator le permite ordenar en un hotel fenomenal en un objeto de negocio, incluso si la propiedad contiene nula, por lo que tendría que decir que es una uso aceptable de un Comparador.