¿Puedo convertir el siguiente código para usar genéricos?

Question

Estoy convirtiendo una aplicación para usar Java 1.5 y encontré el siguiente método:

  /**
   * Compare two Comparables, treat nulls as -infinity.
   * @param o1
   * @param o2
   * @return -1 if o1<o2, 0 if o1==o2, 1 if o1>o2
   */
  protected static int nullCompare(Comparable o1, Comparable o2) {
    if (o1 == null) {
      if (o2 == null) {
        return 0;
      } else {
        return -1;
      }
    } else if (o2 == null) {
      return 1;
    } else {
      return o1.compareTo(o2);
    }
  }

Lo ideal sería que el método tomara dos Comparables del mismo tipo. ¿Es posible convertir esto y cómo?

Pensé que lo siguiente funcionaría:

protected static <T extends Comparable> int nullCompare(T o1, T o2) {

pero no pudo deshacerse de una advertencia en IntelliJ "Llamada no marcada a 'compareTo(T)' como miembro del tipo sin formato 'java.lang.Comparable'" en la línea:

return o1.compareTo(o2);

Answer 1

Cámbielo a:

protected static <T extends Comparable<T>> int nullCompare(T o1, T o2) {

Lo necesita porque Comparable es en sí mismo un tipo genérico.

Answer 2

Aquí hay un caso extraño:

static class A {
    ...
}

static class B extends A implements Comparable<A> {
    public int compareTo(A o) {
        return ...;
    }
}

Afortunadamente, un código como el anterior es poco común, pero nullCompare() no admitirá la comparación de B a menos que se indique que Comparable puede aplicarse a T. o cualquier superclase del mismo:

protected static <T extends Comparable<? super T>> int nullCompare(T o1, T o2) {

Aunque la mayoría de las personas nunca se beneficiarán del ajuste anterior, puede resultar útil al diseñar API para bibliotecas exportadas.

Answer 3

No puedo editar, así que tengo que publicar mi respuesta.

Debe declarar un parámetro de tipo anidado ya que Comparable es genérico.

protected static <T extends Comparable<? super T>> int nullCompare(T o1, T o2) {

Tenga en cuenta que Comparables< ?súper T >, lo que lo hace más flexible.Verá la misma definición de método en Collections.sort

public static <T extends Comparable<? super T>> void sort(List<T> list) {

Answer 4

No estoy seguro de que generalizar este método tenga sentido.Actualmente el método funciona con cualquier tipo de Comparable;si lo generaliza, tendrá que implementarlo (exactamente con el mismo código) varias veces.A veces es posible comparar dos objetos que no tienen un ancestro común y ninguna versión genérica lo permitirá.

Al agregar genéricos no agregarás ninguna seguridad al código;Cualquier problema de seguridad ocurrirá en la llamada a compareTo.Lo que sugeriría es simplemente suprimir la advertencia.Realmente no te advierte sobre nada útil.

Answer 5

Para hacerlo aún más general, incluso podría permitir que funcione para dos tipos diferentes.=P

  /**
   * Compare two Comparables, treat nulls as -infinity.
   * @param o1
   * @param o2
   * @return -1 if o1<o2, 0 if o1==o2, 1 if o1>o2
   */
  protected static <T> int nullCompare(Comparable<? super T> o1, T o2) {
    if (o1 == null) {
      if (o2 == null) {
        return 0;
      } else {
        return -1;
      }
    } else if (o2 == null) {
      return 1;
    } else {
      return o1.compareTo(o2);
    }
  }