Java null ตรวจสอบเหตุใดจึงใช้ == แทน .equals ()

ใน Java ฉันได้รับแจ้งว่าเมื่อทำการตรวจสอบ null ควรใช้ == แทน .equals () อะไรคือสาเหตุของเรื่องนี้?

มันเป็นสองสิ่งที่แตกต่างกันอย่างสิ้นเชิง ==เปรียบเทียบการอ้างอิงอ็อบเจ็กต์หากมีโดยตัวแปร .equals()ตรวจสอบดูว่าวัตถุสองชิ้นเท่ากันตามสัญญาหรือไม่สำหรับความเท่าเทียมกัน เป็นไปได้ทั้งหมดที่อินสแตนซ์ออบเจ็กต์ที่แตกต่างกันสองอินสแตนซ์จะ "เท่ากัน" ตามสัญญา จากนั้นมีรายละเอียดเล็กน้อยที่เนื่องจากequalsเป็นวิธีการหากคุณพยายามเรียกใช้โดยnullอ้างอิงคุณจะได้รับไฟล์NullPointerException.

ตัวอย่างเช่น:

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

ถ้าคุณเรียกใช้.equals()บนnullคุณจะได้รับNullPointerException

ดังนั้นจึงขอแนะนำให้ตรวจสอบความว่างเปล่าก่อนที่จะเรียกใช้วิธีการที่เคยใช้

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

ดูเพิ่มเติม

• ความแตกต่างระหว่าง - เท่ากับ - และ == ใน Java

นอกเหนือจากคำตอบที่ยอมรับ ( https://stackoverflow.com/a/4501084/6276704 ):

ตั้งแต่ Java 1.7 หากคุณต้องการเปรียบเทียบสอง Objects ซึ่งอาจเป็นโมฆะฉันขอแนะนำฟังก์ชันนี้:

Objects.equals(onePossibleNull, twoPossibleNull)

java.util.Objects

คลาสนี้ประกอบด้วยวิธียูทิลิตี้แบบคงที่สำหรับการดำเนินการกับอ็อบเจ็กต์ ยูทิลิตี้เหล่านี้รวมถึงเมธอด null-safe หรือ null-tolerant สำหรับการคำนวณรหัสแฮชของอ็อบเจ็กต์การส่งคืนสตริงสำหรับอ็อบเจ็กต์และเปรียบเทียบอ็อบเจ็กต์สองชิ้น

ตั้งแต่: 1.7

ใน Java 0 หรือ null เป็นประเภทธรรมดาไม่ใช่อ็อบเจ็กต์

วิธีการเท่ากับ () ไม่ได้ถูกสร้างขึ้นสำหรับประเภทที่เรียบง่าย ประเภทอย่างง่ายสามารถจับคู่กับ ==

foo.equals(null)

จะเกิดอะไรขึ้นถ้า foo เป็นโมฆะ?

คุณจะได้รับ NullPointerException

ถ้าตัวแปร Object เป็นโมฆะไม่มีใครสามารถเรียกใช้เมธอด equals () ได้ดังนั้นการตรวจสอบการอ้างอิงอ็อบเจ็กต์ของ null จึงเหมาะสม

หากคุณลองเรียกเท่ากับในการอ้างอิงวัตถุว่างคุณจะได้รับข้อยกเว้นของตัวชี้ค่าว่าง

ตามแหล่งที่มาไม่สำคัญว่าจะใช้อะไรสำหรับการใช้งานวิธีการเริ่มต้น:

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

แต่คุณไม่แน่ใจเกี่ยวกับequalsคลาสที่กำหนดเอง

ถ้าเราใช้วิธี => .equals

if(obj.equals(null))  

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

เมื่อ obj ของคุณเป็นโมฆะมันจะโยน Null Point Exception

ดังนั้นเราควรใช้ ==

if(obj == null)

มันจะเปรียบเทียบการอ้างอิง

Object.equals เป็น null ที่ปลอดภัยอย่างไรก็ตามโปรดทราบว่าหากวัตถุสองชิ้นเป็นโมฆะ object.equals จะคืนค่าจริงดังนั้นโปรดตรวจสอบว่าวัตถุที่คุณกำลังเปรียบเทียบไม่ใช่ null (หรือเก็บค่า null) ก่อนที่จะใช้ object การเปรียบเทียบ

String firstname = null;
String lastname = null;

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

ตัวอย่างข้อมูลด้านบนจะคืนค่าเท่ากัน!

เนื่องจากเท่ากับเป็นฟังก์ชันที่ได้มาจากคลาส Object ฟังก์ชันนี้จึงเปรียบเทียบรายการของคลาส ถ้าคุณใช้กับ null มันจะส่งคืนเนื้อหาสาเหตุที่เป็นเท็จสาเหตุที่เป็นเท็จไม่เป็นโมฆะ นอกจากนี้ == เปรียบเทียบการอ้างอิงกับวัตถุ

นี่คือตัวอย่างที่str != nullแต่str.equals(null)เมื่อใช้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

แก้ไข: นี่คือคลาส org.json.JSONObject $ Null :

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

ดังนั้นฉันจึงไม่สับสนและหลีกเลี่ยงปัญหาเกี่ยวกับวิธีแก้ปัญหานี้:

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

ฉันเคยเจอกรณีนี้เมื่อคืนนี้
ฉันพิจารณาแล้วว่า:

ไม่มีเมธอด equals ()สำหรับnull
ดังนั้นคุณไม่สามารถเรียกใช้เมธอดที่ไม่มีอยู่ได้หากคุณไม่มี
- >>> นั่นคือเหตุผลว่าทำไมเราถึงใช้==เพื่อตรวจสอบnull

รหัสคุณละเมิดกฎของ Demeter นั่นเป็นเหตุผลที่ดีกว่าที่จะปรับโครงสร้างการออกแบบใหม่ คุณสามารถใช้ตัวเลือกเสริมได้

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

ด้านบนคือการตรวจสอบลำดับชั้นของวัตถุดังนั้นให้ใช้

Optional.ofNullable(object1) 

หากคุณมีวัตถุที่จะตรวจสอบเพียงชิ้นเดียว

หวังว่านี่จะช่วยได้ !!!!

คุณสามารถทำได้เสมอ

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

ขั้นแรกจะตรวจสอบการอ้างอิงอ็อบเจ็กต์จากนั้นตรวจสอบอ็อบเจ็กต์ที่ระบุว่าการอ้างอิงไม่เป็นโมฆะ