web-dev-qa-db-fra.com

Java null vérifier pourquoi utiliser == au lieu de .equals ()

Dans Java on me dit que lors d'une vérification nulle, on devrait utiliser == au lieu de .equals (). Quelles sont les raisons pour cela?

javanull
108
Jim Jeffries

Ce sont deux choses complètement différentes. == compare la référence d'objet, le cas échéant, contenue par une variable. .equals() vérifie si deux objets sont égaux en fonction de leur contrat pour ce que signifie l'égalité. Il est tout à fait possible que deux instances d'objet distinctes soient "égales" en fonction de leur contrat. Et puis il y a le détail mineur que puisque equals est une méthode, si vous essayez de l'invoquer sur une référence null, vous obtiendrez un NullPointerException.

Par exemple:

class Foo {
    private int data;

    Foo(int d) {
        this.data = d;
    }

    @Override
    public boolean equals(Object other) {
        if (other == null || other.getClass() != this.getClass()) {
           return false;
        }
        return ((Foo)other).data == this.data;
    }

    /* In a real class, you'd override `hashCode` here as well */
}

Foo f1 = new Foo(5);
Foo f2 = new Foo(5);
System.out.println(f1 == f2);
// outputs false, they're distinct object instances

System.out.println(f1.equals(f2));
// outputs true, they're "equal" according to their definition

Foo f3 = null;
System.out.println(f3 == null);
// outputs true, `f3` doesn't have any object reference assigned to it

System.out.println(f3.equals(null));
// Throws a NullPointerException, you can't dereference `f3`, it doesn't refer to anything

System.out.println(f1.equals(f3));
// Outputs false, since `f1` is a valid instance but `f3` is null,
// so one of the first checks inside the `Foo#equals` method will
// disallow the equality because it sees that `other` == null
165
T.J. Crowder

si vous appelez .equals() sur null vous obtiendrez NullPointerException

Donc, il est toujours conseillé de vérifier la nullité avant d'appeler la méthode où qu'elle s'applique

if(str!=null && str.equals("hi")){
 //str contains hi
}

Voir aussi

33
Jigar Joshi

En plus de la réponse acceptée ( https://stackoverflow.com/a/4501084/6276704 ):

Depuis Java 1.7, si vous voulez comparer deux objets pouvant être nuls, je vous recommande cette fonction:

Objects.equals(onePossibleNull, twoPossibleNull)

Java.util.Objects

Cette classe comprend des méthodes utilitaires statiques permettant d’opérer sur des objets. Ces utilitaires incluent des méthodes null-safe ou tolérantes pour le calcul du code de hachage d'un objet, le retour d'une chaîne pour un objet et la comparaison de deux objets.

Depuis: 1.7

18
BluE

Dans Java, _ 0 ou null sont des types simples et non des objets.

La méthode equals () n'est pas construite pour les types simples. Les types simples peuvent être jumelés avec ==.

17
user523859
foo.equals(null)

Que se passe-t-il si foo est null?

Vous obtenez une exception NullPointerException.

4
Nick Orton

Si une variable Object est null, il est impossible d'appeler une méthode equals (), une vérification de référence d'objet de null est donc correcte.

2
Jé Queue

Si vous essayez d'appeler égaux sur une référence d'objet null, vous obtiendrez une exception de pointeur null.

2
A_M

Si nous utilisons la méthode => .equals

if(obj.equals(null))  

// Which mean null.equals(null) when obj will be null.

Lorsque votre obj sera nul, il lancera une exception de point nul.

nous devrions donc utiliser ==

if(obj == null)

il va comparer les références.

2
AKT

Selon sources peu importe ce qu'il faut utiliser pour l'implémentation de méthode par défaut:

public boolean equals(Object object) {
    return this == object;
}

Mais vous ne pouvez pas être sûr de equals dans une classe personnalisée.

2
DixonD

Equal étant une fonction dérivée de la classe Object, cette fonction compare les éléments de la classe. si vous l'utilisez avec null, il retournera une cause fausse car le contenu de la classe n'est pas nul. De plus == compare la référence à un objet.

1
danny.lesnik

voici un exemple où str != null mais str.equals(null) lors de l'utilisation de org.json

 JSONObject jsonObj = new JSONObject("{field :null}");
 Object field = jsonObj.get("field");
 System.out.println(field != null);        // => true
 System.out.println( field.equals(null)); //=> true
 System.out.println( field.getClass());  // => org.json.JSONObject$Null




EDIT: voici le org.json.JSONObject $ Null classe:

/**
 * JSONObject.NULL is equivalent to the value that JavaScript calls null,
 * whilst Java's null is equivalent to the value that JavaScript calls
 * undefined.
 */
private static final class Null {

    /**
     * A Null object is equal to the null value and to itself.
     *
     * @param object
     *            An object to test for nullness.
     * @return true if the object parameter is the JSONObject.NULL object or
     *         null.
     */
    @Override
    public boolean equals(Object object) {
        return object == null || object == this;
    }  
}
1
dina

Donc, je ne m'embrouille jamais et évite les problèmes avec cette solution:

if(str.trim().length() <=0 ) {
   // is null !
}
0
Matheus Marques

J'ai rencontré ce cas hier soir.
Je détermine simplement que:

N'existez pas méthode equals () pour null
Donc, vous ne pouvez pas invoquer une méthode inexistante si vous n'avez pas
- >>> C'est pour cette raison que nous utilisons == pour vérifier null

0
Neo_