Puis-je convertir le code suivant pour utiliser des génériques ?

Question

Je convertis une application pour utiliser Java 1.5 et j'ai trouvé la méthode suivante :

  /**
   * 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);
    }
  }

Idéalement, j'aimerais que la méthode prenne deux comparables du même type, est-il possible de les convertir et comment ?

Je pensais que ce qui suit ferait l'affaire :

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

mais il n'a pas réussi à supprimer un avertissement dans IntelliJ "Appel non vérifié à 'compareTo(T)' en tant que membre du type brut 'java.lang.Comparable'" sur la ligne :

return o1.compareTo(o2);

Answer 1

Remplacez-le par :

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

Vous en avez besoin car Comparable est lui-même un type générique.

Answer 2

Voici un cas étrange :

static class A {
    ...
}

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

Heureusement, un code comme celui ci-dessus est rare, mais nullCompare() ne prendra pas en charge la comparaison de Bs à moins qu'il ne soit indiqué que Comparable peut s'appliquer à T. ou toute superclasse de celui-ci:

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

Même si la plupart des gens ne bénéficieront jamais de l’ajustement ci-dessus, il peut s’avérer utile lors de la conception d’API pour les bibliothèques exportées.

Answer 3

Impossible de modifier, je dois donc publier ma réponse.

Vous devez déclarer un paramètre de type imbriqué puisque Comparable est générique.

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

Veuillez noter que Comparable< ?super T >, ce qui rend plus flexible.Vous verrez la même définition de méthode sur Collections.sort

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

Answer 4

Je ne suis pas sûr que généraliser cette méthode ait du sens.Actuellement, la méthode fonctionne sur tout type de comparable ;si vous le génériquez, vous devrez l'implémenter (avec exactement le même code) plusieurs fois.Parfois, il est possible de comparer deux objets qui n'ont pas d'ancêtre commun, et aucune version générique ne le permet.

En ajoutant des génériques, vous n'ajouterez aucune sécurité au code ;tout problème de sécurité surviendra lors de l’appel à compareTo.Ce que je suggérerais, c'est simplement de supprimer l'avertissement.Cela ne vous avertit pas vraiment de quoi que ce soit d'utile.

Answer 5

Pour le rendre encore plus général, vous pouvez même lui permettre de fonctionner pour deux types différents.=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);
    }
  }