Java null, neden .equals () yerine == kullanıldığını kontrol edin

Java'da null kontrol yaparken .equals () yerine == kullanılması gerektiği söylendi. Bunun nedenleri nelerdir?

Tamamen farklı iki şey. ==eğer varsa, bir değişkenin içerdiği nesne referansını karşılaştırır. eşitliğin ne anlama geldiği konusunda .equals()iki nesnenin sözleşmelerine göre eşit olup olmadığını kontrol eder . İki farklı nesne örneğinin sözleşmelerine göre "eşit" olması tamamen mümkündür. Ve sonra equalsbir yöntem olduğu için küçük bir ayrıntı var , eğer onu bir nullreferansta çağırmaya çalışırsanız , bir NullPointerException.

Örneğin:

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

Eğer çağırmak varsa .equals()üzerine nullalacakNullPointerException

Bu nedenle, geçerli olduğu her durumda yöntemi çağırmadan önce geçersizliği kontrol etmeniz her zaman tavsiye edilir.

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

Ayrıca Bakın

• Java'da eşittir ve == arasındaki fark

Kabul edilen cevaba ek olarak ( https://stackoverflow.com/a/4501084/6276704 ):

Java 1.7'den beri, boş olabilecek iki Nesneyi karşılaştırmak istiyorsanız, bu işlevi tavsiye ederim:

Objects.equals(onePossibleNull, twoPossibleNull)

java.util.Objects

Bu sınıf, nesneler üzerinde çalışmak için statik fayda yöntemlerinden oluşur. Bu yardımcı programlar, bir nesnenin karma kodunu hesaplamak, bir nesne için bir dize döndürmek ve iki nesneyi karşılaştırmak için boş güvenlikli veya boş toleranslı yöntemleri içerir.

Beri: 1.7

Java'da 0 veya null basit türlerdir ve nesneler değildir.

Eşittir () yöntemi basit türler için oluşturulmamıştır. Basit türler == ile eşleştirilebilir.

foo.equals(null)

Foo null olursa ne olur?

NullPointerException alırsınız.

Bir Object değişkeni null ise, bunun üzerine bir equals () yöntemi çağrılamaz, dolayısıyla boş olan bir nesne referans kontrolü uygundur.

Boş bir nesne başvurusunda eşittir çağırmayı denerseniz, atılan bir boş işaretçi istisnası alırsınız.

Kaynaklara göre, varsayılan yöntem uygulaması için ne kullanılacağı önemli değil:

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

Ancak equalsözel sınıfta emin olamazsınız .

=> .Equals yöntemini kullanırsak

if(obj.equals(null))  

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

Nesneniz boş olduğunda Null Point Exception atacaktır.

bu yüzden == kullanmalıyız

if(obj == null)

referansları karşılaştıracaktır.

Object.equals boş güvenlidir, ancak iki nesne boşsa, object.equals true döndürür, bu nedenle object.equals'ı kullanmadan önce karşılaştırdığınız nesnelerin boş olmadığını (veya boş değerleri tuttuğunu) kontrol ettiğinizden emin olun. karşılaştırması.

String firstname = null;
String lastname = null;

if(Objects.equals(firstname, lastname)){
    System.out.println("equal!");
} else {
    System.out.println("not equal!");
}

Yukarıdaki örnek snippet eşit olarak dönecektir!

Eşit, Object sınıfından türetilmiş bir işlev olduğundan, bu işlev sınıfın öğelerini karşılaştırır. Eğer onu null ile kullanırsanız, yanlış bir sebep döndürür, çünkü sınıf içeriği boş değildir. Ek olarak == bir nesneye yapılan referansı karşılaştırır.

burada bir örnek str != nullama str.equals(null)kullanırkenorg.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

DÜZENLEME: işte org.json.JSONObject $ Null sınıfı:

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

Bu yüzden asla kafam karışmaz ve bu çözümle ilgili sorunlardan kaçınmam:

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

Dün gece bu davayla karşılaştım.
Bunu basitçe belirledim:

Null için equals () yöntemi yok Bu nedenle, eğer sahip değilseniz, varolmayan bir yöntemi çağıramazsınız - >>> Kontrol etmek için == kullanmamızın nedeni budur

null adlı

Kodun Demeter kanununu çiğniyorsun. Bu yüzden tasarımın kendisini yeniden düzenlemek daha iyidir. Geçici bir çözüm olarak, İsteğe bağlı

   obj = Optional.ofNullable(object1)
    .map(o -> o.getIdObject11())
    .map(o -> o.getIdObject111())
    .map(o -> o.getDescription())
    .orElse("")

yukarıdaki bir nesnenin hiyerarşisini kontrol etmektir, bu nedenle

Optional.ofNullable(object1) 

kontrol edilecek tek bir nesneniz varsa

Bu yardımcı olur umarım !!!!

Her zaman yapabilirsin

if (str == null || str.equals(null))

Bu, önce nesne referansını kontrol edecek ve ardından referansın boş olmadığını sağlayarak nesnenin kendisini kontrol edecektir.