Java: null sûre méthode compareTo

Retour 0 impliquerait que this et o sont égales, ce qui n'est pas vrai si o est null. Aussi, this ne sera jamais nulle.

Il dépend de l'application, bien sûr. Vous souhaitez avoir un objet qui doit être égale à null. Ce que vous de retour, il est à vous, mais si vous êtes à la recherche d'un général null méthode sûre, il n'est pas vraiment idéal.

Être complètement générique, je voudrais vérifier si o est null et, le cas échéant, de lancer une sorte d'Exception.

OriginalL'auteur EMMERICH

De la comparaison de deux objets peuvent être aussi nul sûre que toute autre méthode, le problème ici est qu'une méthode normale a deux paramètres, mais compareTo reçoit l'un et l'autre est l'objet lui-même.

this ne peut JAMAIS être nulle, ce qui voudrait dire que vous êtes l'exécution de code dans un null objet (pas d'exemple). Dans ce cas, un NullPointerException vont être jetées à droite à l'invocation de compareTo, rendant impossible l'exécution de son code.

Il y a autant d'approches que les objets, parce qu'une comparaison peut être établie dans le champs d'une classe qui PEUT être null (destiné à des bouchons d'exclure des types primitifs). Donc, c'est une longue histoire courte, votre null vérifications doivent couvrir l'objet que vous recevez en tant que paramètre dans compareTo et les champs. En outre, si vous avez une instance externe qui contient un peu de logique (c'est à dire une classe d'utilitaires), vous devriez vérifier si cette instance est également nulle.

Comme une note de côté, tout ce que vous de retour si tout objet est null doit être cohérente et documentée (vous pouvez revenir à -1 ou 1, à la place des zéros au début ou à la fin). Juste éviter de revenir à 0 (ce qui serait le même cas que si equals retourné true pour un null objet.

OriginalL'auteur Gamb

L'auteur insistant sur le fait qu'il ne veut pas supprimer les valeurs nulles de son
Tok[].

Voici une soultion qui permet de trier avec les valeurs NULL, et ne viole java contrats

Pour éviter cela, vous créez un compareTo à l'intérieur de la classe Tok qui viole la compareTo contrat,
vous créez un explicite NullSafeComparator:

 /**
 * This comparator accepts null objects,
 * sorts ascending, null values are after non null values.
 */
public static final class NullSafeComparator implements Comparator<Tok> {
    public int compare(Tok o1, Tok o2) {
        int r1 = Integer.MAX_VALUE;
        int r2 = Integer.MAX_VALUE;
        if (o1 != null) {
            r1 = o1.rang;
        }
        if (o2 != null) {
            r2 = o2.rang;
        }
        return (r1 < r2 ? -1 : (r1 == r2 ? 0 : 1));
    }
}

simplifié de la classe Tok (supprimer le mot-clé static son est utilisé pour définir tous à l'intérieur d'une unité de la classe de test):

public static class Tok {
    int rang;
    public Tok(int rang) {
        this.rang = rang;
    }
    public String toString() {
        return Integer.toString(rang);
    }
}

Enfin un test unitaire pour montrer:

public void testSort() {

    Tok[] toks = new Tok[5];
    toks[0] = new Tok(3);
    toks[1] = new Tok(1);
    toks[2] = null;
    toks[3] = null;
    toks[4] = new Tok(2);



    Arrays.sort(toks, new NullSafeComparator());



    for (Tok tok: toks) {
        System.out.println(tok);
    }
    assertEquals(1, toks[0]);
    assertNull(toks[4]);
}

Qui va donner comme résultat souhaité:

1
2
3
null
null

OriginalL'auteur AlexWien