Bandingkan dua objek di Jawa dengan kemungkinan nilai nol

Saya ingin membandingkan dua string untuk kesetaraan di Jawa, ketika salah satu atau keduanya bisa null, jadi saya tidak bisa begitu saja menelepon .equals(). Apakah cara terbaiknya?

boolean compare(String str1, String str2) {
    ...
}

Edit:

return ((str1 == str2) || (str1 != null && str1.equals(str2)));

Inilah yang digunakan kode internal Java (pada comparemetode lain ):

public static boolean compare(String str1, String str2) {
    return (str1 == null ? str2 == null : str1.equals(str2));
}

Karena Java 7 Anda dapat menggunakan metode statis java.util.Objects.equals(Object, Object)untuk melakukan pemeriksaan yang sama pada dua objek tanpa peduli keberadaannya null.

Jika kedua objek nullitu akan kembali true, jika satu nulldan yang lain bukan akan kembali false. Kalau tidak, itu akan mengembalikan hasil memanggil equalsobjek pertama dengan yang kedua sebagai argumen.

Untuk kasus-kasus ini akan lebih baik menggunakan sama dengan Apache Commons StringUtils # , itu sudah menangani string null. Contoh kode:

public boolean compare(String s1, String s2) {
    return StringUtils.equals(s1, s2);
}

Jika Anda tidak ingin menambahkan perpustakaan, hanya menyalin kode sumber dari StringUtils#equalsmetode dan menerapkannya ketika Anda membutuhkannya.

Bagi mereka yang menggunakan Android, yang tidak dapat menggunakan Objects.equals API 19 (str1, str2), ada ini:

android.text.TextUtils.equals(str1, str2);

Ini nol aman. Jarang harus menggunakan metode string.equals () yang lebih mahal karena string identik pada android hampir selalu benar dibandingkan dengan operan "==" berkat String Pooling Android , dan pengecekan panjang adalah cara cepat untuk menyaring sebagian besar ketidakcocokan.

Kode sumber:

/**
 * Returns true if a and b are equal, including if they are both null.
 * <p><i>Note: In platform versions 1.1 and earlier, this method only worked  well if
 * both the arguments were instances of String.</i></p>
 * @param a first CharSequence to check
 * @param b second CharSequence to check
 * @return true if a and b are equal
 */
public static boolean equals(CharSequence a, CharSequence b) {
    if (a == b) return true;
    int length;
    if (a != null && b != null && (length = a.length()) == b.length()) {
        if (a instanceof String && b instanceof String) {
            return a.equals(b);
        } else {
            for (int i = 0; i < length; i++) {
                if (a.charAt(i) != b.charAt(i)) return false;
            }
            return true;
        }
    }
    return false;
}

Sejak versi 3.5 Apache Commons StringUtils memiliki metode berikut:

static int  compare(String str1, String str2)
static int  compare(String str1, String str2, boolean nullIsLess)
static int  compareIgnoreCase(String str1, String str2)
static int  compareIgnoreCase(String str1, String str2, boolean nullIsLess)

Ini memberikan perbandingan String aman nol.

Menggunakan Java 8:

private static Comparator<String> nullSafeStringComparator = Comparator
        .nullsFirst(String::compareToIgnoreCase); 

private static Comparator<Metadata> metadataComparator = Comparator
        .comparing(Metadata::getName, nullSafeStringComparator)
        .thenComparing(Metadata::getValue, nullSafeStringComparator);

public int compareTo(Metadata that) {
    return metadataComparator.compare(this, that);
}

Bandingkan dua string menggunakan equals (-, -) dan metode equalsIgnoreCase (-, -) dari kelas Apache Commons StringUtils.

StringUtils.equals (-, -) :

StringUtils.equals(null, null)   = true
StringUtils.equals(null, "abc")  = false
StringUtils.equals("abc", null)  = false
StringUtils.equals("abc", "abc") = true
StringUtils.equals("abc", "ABC") = false

StringUtils.equalsIgnoreCase (-, -) :

StringUtils.equalsIgnoreCase(null, null)   = true
StringUtils.equalsIgnoreCase(null, "abc")  = false
StringUtils.equalsIgnoreCase("xyz", null)  = false
StringUtils.equalsIgnoreCase("xyz", "xyz") = true
StringUtils.equalsIgnoreCase("xyz", "XYZ") = true

Anda bisa menggunakan java.util.Objectssebagai berikut.

public static boolean compare(String str1, String str2) {
    return Objects.equals(str1, str2);
}

boolean compare(String str1, String str2) {
    if(str1==null || str2==null) {
        //return false; if you assume null not equal to null
        return str1==str2;
    }
    return str1.equals(str2);
}

apakah ini yang kamu inginkan?

boolean compare(String str1, String str2) {
    if (str1 == null || str2 == null)
        return str1 == str2;

    return str1.equals(str2);
}

boolean compare(String str1, String str2) {
  return (str1==null || str2==null) ? str1 == str2 : str1.equals(str2);
}

OK, jadi apa artinya "solusi terbaik"?

Jika yang Anda maksud paling mudah dibaca, maka semua solusi yang mungkin cukup banyak setara untuk seorang programmer Java yang berpengalaman. Tapi IMO yang paling mudah dibaca adalah ini

 public boolean compareStringsOrNulls(String str1, String str2) {
     // Implement it how you like
 }

Dengan kata lain, sembunyikan implementasi di dalam metode sederhana yang (idealnya) dapat digarisbawahi.

(Anda juga bisa "out-source" ke perpustakaan utilitas pihak ke-3 ... jika Anda sudah menggunakannya dalam basis kode Anda.)

Jika yang Anda maksud adalah sebagian besar pemain, maka:

1. solusi yang paling berkinerja tergantung pada platform dan konteksnya,
2. salah satu "konteks" masalah adalah frekuensi relatif (dinamis) terjadinya nullargumen,
3. itu mungkin tidak masalah versi yang lebih cepat ... karena perbedaan mungkin terlalu kecil untuk membuat perbedaan untuk kinerja aplikasi secara keseluruhan, dan
4. jika itu penting, satu-satunya cara untuk mencari tahu mana yang tercepat DI PLATFORM ANDA adalah dengan mencoba kedua versi dan mengukur perbedaannya.