Bagaimana cara membandingkan string di Jawa?

Saya telah menggunakan ==operator dalam program saya untuk membandingkan semua string saya sejauh ini. Namun, saya menemukan bug, mengubah salah satunya .equals(), dan memperbaiki bug.

Apakah ==buruk? Kapan sebaiknya dan tidak boleh digunakan? Apa bedanya?

== tes untuk persamaan referensi (apakah mereka adalah objek yang sama).

.equals() menguji kesetaraan nilai (apakah secara logis "sama").

Objects.equals () memeriksa nullsebelum memanggil .equals()sehingga Anda tidak perlu (tersedia pada JDK7, juga tersedia di Guava ).

Akibatnya, jika Anda ingin menguji apakah dua string memiliki nilai yang sama, Anda mungkin ingin menggunakannya Objects.equals().

// These two have the same value
new String("test").equals("test") // --> true 

// ... but they are not the same object
new String("test") == "test" // --> false 

// ... neither are these
new String("test") == new String("test") // --> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" // --> true 

// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true

// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true

Anda hampir selalu ingin menggunakannya Objects.equals(). Dalam situasi langka di mana Anda tahu Anda berurusan dengan string yang diinternir , Anda dapat menggunakannya ==.

Dari JLS 3.10.5. String Literals :

Selain itu, literal string yang selalu mengacu pada yang sama instance dari kelas String. Ini karena string literal - atau, lebih umum, string yang merupakan nilai dari ekspresi konstan ( §15.28 ) - "diinternir" sehingga dapat berbagi contoh yang unik, menggunakan metode ini String.intern.

Contoh serupa juga dapat ditemukan di JLS 3.10.5-1 .

Metode Lain Untuk Dipertimbangkan

String.equalsIgnoreCase () nilai kesetaraan yang mengabaikan case.

String.contentEquals () membandingkan konten Stringdengan konten apa saja CharSequence(tersedia sejak Java 1.5). Menghemat Anda dari keharusan mengubah StringBuffer Anda, dll menjadi String sebelum melakukan perbandingan kesetaraan, tetapi membiarkan null memeriksa Anda.

==menguji referensi objek, .equals()menguji nilai string.

Kadang-kadang terlihat ==membandingkan nilai, karena Java melakukan beberapa hal di belakang layar untuk memastikan string in-line yang identik sebenarnya adalah objek yang sama.

Sebagai contoh:

String fooString1 = new String("foo");
String fooString2 = new String("foo");

// Evaluates to false
fooString1 == fooString2;

// Evaluates to true
fooString1.equals(fooString2);

// Evaluates to true, because Java uses the same object
"bar" == "bar";

Namun waspadalah terhadap nol!

==menangani nullstring dengan baik, tetapi panggilan .equals()dari string nol akan menyebabkan pengecualian:

String nullString1 = null;
String nullString2 = null;

// Evaluates to true
System.out.print(nullString1 == nullString2);

// Throws a NullPointerException
System.out.print(nullString1.equals(nullString2));

Jadi, jika Anda tahu itu fooString1mungkin nol, beri tahu pembaca bahwa dengan menulis

System.out.print(fooString1 != null && fooString1.equals("bar"));

Berikut ini lebih pendek, tetapi kurang jelas untuk memeriksa null:

System.out.print("bar".equals(fooString1));  // "bar" is never null
System.out.print(Objects.equals(fooString1, "bar"));  // Java 7 required

== membandingkan referensi Objek.

.equals() membandingkan nilai String.

Terkadang ==memberikan ilusi untuk membandingkan nilai String, seperti dalam kasus berikut:

String a="Test";
String b="Test";
if(a==b) ===> true

Ini karena ketika Anda membuat String literal apa pun, JVM pertama mencari literal tersebut di kumpulan String, dan jika menemukan kecocokan, referensi yang sama akan diberikan ke String baru. Karena itu, kita dapat:

(a == b) ===> true

                       String Pool
     b -----------------> "test" <-----------------a

Namun, ==gagal dalam kasus berikut:

String a="test";
String b=new String("test");
if (a==b) ===> false

Dalam hal ini untuk new String("test")pernyataan String baru akan dibuat di heap, dan referensi itu akan diberikan kepada b, jadi bakan diberikan referensi di heap, bukan di string pool.

Sekarang amenunjuk ke String di kolam String sementara bmenunjuk ke String di heap. Karena itu kita dapatkan:

jika (a == b) ===> false.

                String Pool
     "test" <-------------------- a

                   Heap
     "test" <-------------------- b

Meskipun .equals()selalu membandingkan nilai String sehingga memberi benar dalam kedua kasus:

String a="Test";
String b="Test";
if(a.equals(b)) ===> true

String a="test";
String b=new String("test");
if(a.equals(b)) ===> true

Jadi menggunakan .equals()selalu lebih baik.

The ==cek operator untuk melihat apakah dua string yang persis objek yang sama.

The .equals()Metode akan memeriksa apakah dua string memiliki nilai yang sama.

String di Jawa tidak berubah. Itu berarti setiap kali Anda mencoba mengubah / memodifikasi string Anda mendapatkan contoh baru. Anda tidak dapat mengubah string asli. Ini telah dilakukan sehingga instance string ini dapat di-cache. Sebuah program tipikal berisi banyak referensi string dan caching instance ini dapat mengurangi jejak memori dan meningkatkan kinerja program.

Saat menggunakan operator == untuk perbandingan string, Anda tidak membandingkan konten string, tetapi sebenarnya membandingkan alamat memori. Jika keduanya sama maka akan mengembalikan true dan false sebaliknya. Sedangkan equals in string membandingkan konten string.

Jadi pertanyaannya adalah jika semua string di-cache dalam sistem, mengapa ==return salah sedangkan equal mengembalikan true? Ya, ini mungkin. Jika Anda membuat string baru seperti String str = new String("Testing")Anda akhirnya membuat string baru di cache bahkan jika cache sudah mengandung string yang memiliki konten yang sama. Singkatnya "MyString" == new String("MyString")akan selalu mengembalikan false.

Java juga berbicara tentang fungsi intern () yang dapat digunakan pada string untuk menjadikannya bagian dari cache sehingga "MyString" == new String("MyString").intern()akan mengembalikan true.

Catatan: operator == jauh lebih cepat daripada yang sama hanya karena Anda membandingkan dua alamat memori, tetapi Anda perlu memastikan bahwa kode tersebut tidak membuat instance String baru dalam kode. Kalau tidak, Anda akan menemukan bug.

String a = new String("foo");
String b = new String("foo");
System.out.println(a == b); // prints false
System.out.println(a.equals(b)); // prints true

Pastikan Anda mengerti alasannya. Itu karena ==perbandingan hanya membandingkan referensi; yang equals()metode melakukan perbandingan karakter-karakter dari isi.

Ketika Anda memanggil baru untuk adan b, masing-masing mendapat referensi baru yang menunjuk ke "foo"dalam tabel string. Referensi berbeda, tetapi isinya sama.

Ya itu buruk ...

==berarti bahwa dua referensi string Anda adalah objek yang persis sama. Anda mungkin pernah mendengar bahwa ini adalah kasusnya karena Java menyimpan semacam tabel literal (yang memang demikian), tetapi tidak selalu demikian. Beberapa string dimuat dengan cara yang berbeda, dibuat dari string lain, dll., Jadi Anda tidak boleh berasumsi bahwa dua string identik disimpan di lokasi yang sama.

Sama dengan melakukan perbandingan nyata untuk Anda.

Ya, ==buruk untuk membandingkan Strings (objek apa pun, kecuali Anda tahu itu kanonik). ==hanya membandingkan referensi objek. .equals()tes untuk kesetaraan. Untuk Strings, seringkali mereka akan sama tetapi seperti yang Anda temukan, itu tidak selalu dijamin.

Java memiliki kumpulan String di mana Java mengelola alokasi memori untuk objek String. Lihat Kolam Tali di Jawa

Saat Anda memeriksa (membandingkan) dua objek menggunakan ==operator, ia membandingkan kesetaraan alamat ke dalam kumpulan string. Jika dua objek String memiliki referensi alamat yang sama maka kembali true, jika tidak false. Tetapi jika Anda ingin membandingkan konten dari dua objek String maka Anda harus menggantiequals metode.

equals sebenarnya adalah metode kelas Object, tetapi Overridden ke dalam kelas String dan definisi baru diberikan yang membandingkan konten objek.

Example:
    stringObjectOne.equals(stringObjectTwo);

Tapi pikiran menghargai kasus String. Jika Anda ingin membandingkan huruf besar-kecil maka Anda harus menggunakan metode equalsIgnoreCase dari kelas String.

Ayo lihat:

String one   = "HELLO"; 
String two   = "HELLO"; 
String three = new String("HELLO"); 
String four  = "hello"; 

one == two;   // TRUE
one == three; // FALSE
one == four;  // FALSE

one.equals(two);            // TRUE
one.equals(three);          // TRUE
one.equals(four);           // FALSE
one.equalsIgnoreCase(four); // TRUE

Saya setuju dengan jawaban dari zacherate.

Tapi yang bisa Anda lakukan adalah menelepon intern() string non-literal Anda.

Dari contoh zacherate:

// ... but they are not the same object
new String("test") == "test" ==> false 

Jika Anda magang, persamaan String non-literal adalah true:

new String("test").intern() == "test" ==> true 

==membandingkan referensi objek di Jawa , dan itu tidak terkecuali untukString objek.

Untuk membandingkan konten objek yang sebenarnya (termasuk String), seseorang harus menggunakan equalsmetode ini .

Jika perbandingan dua Stringobjek menggunakan ==ternyata true, itu karena Stringobjek diinternir, dan Java Virtual Machine memiliki beberapa titik referensi ke contoh yang sama String. Orang seharusnya tidak berharap bahwa membandingkan satu Stringobjek yang berisi konten yang sama dengan Stringobjek lain gunakan ==untuk mengevaluasi sebagai true.

.equals() membandingkan data dalam suatu kelas (dengan asumsi fungsi diimplementasikan). ==membandingkan lokasi penunjuk (lokasi objek dalam memori).

==mengembalikan true jika kedua objek (TIDAK BICARA TENTANG PRIMITIF) menunjuk ke instance objek SAMA. .equals()mengembalikan true jika dua objek berisi data yang sama equals()Versus== di Jawa

Itu mungkin bisa membantu Anda.

==melakukan pemeriksaan kesetaraan referensi , apakah 2 objek (string dalam kasus ini) merujuk ke objek yang sama dalam memori.

The equals()Metode akan memeriksa apakah isi atau negara dari 2 objek yang sama.

Jelas ==lebih cepat, tetapi akan (mungkin) memberikan hasil yang salah dalam banyak kasus jika Anda hanya ingin tahu apakah 2 Strings memegang teks yang sama.

equals()Disarankan penggunaan metode ini.

Jangan khawatir tentang kinerjanya. Beberapa hal untuk didorong menggunakan String.equals():

1. Implementasi String.equals()pemeriksaan pertama untuk persamaan referensi (menggunakan ==), dan jika 2 string adalah sama dengan referensi, tidak ada perhitungan lebih lanjut yang dilakukan!
2. Jika referensi 2 string tidak sama, String.equals()selanjutnya akan memeriksa panjang string. Ini juga merupakan operasi cepat karena Stringkelas menyimpan panjang string, tidak perlu menghitung karakter atau poin kode. Jika panjangnya berbeda, tidak ada pemeriksaan lebih lanjut dilakukan, kami tahu mereka tidak bisa sama.
3. Hanya jika kita sampai sejauh ini maka isi dari 2 string akan benar-benar dibandingkan, dan ini akan menjadi perbandingan singkat: tidak semua karakter akan dibandingkan, jika kita menemukan karakter yang tidak cocok (pada posisi yang sama dalam 2 string) ), tidak ada karakter lebih lanjut akan diperiksa.

Ketika semua dikatakan dan dilakukan, bahkan jika kami memiliki jaminan bahwa string adalah magang, menggunakan equals()metode ini masih tidak overhead yang orang mungkin berpikir, pasti cara yang disarankan. Jika Anda ingin pemeriksaan referensi yang efisien, maka gunakan enums di mana dijamin oleh spesifikasi bahasa dan implementasi bahwa nilai enum yang sama akan menjadi objek yang sama (dengan referensi).

Jika Anda seperti saya, ketika saya mulai menggunakan Java, saya ingin menggunakan operator "==" untuk menguji apakah dua instance String sama, tetapi untuk lebih baik atau lebih buruk, itu bukan cara yang tepat untuk melakukannya di Jawa.

Dalam tutorial ini saya akan menunjukkan beberapa cara berbeda untuk membandingkan string Java dengan benar, dimulai dengan pendekatan yang saya gunakan sebagian besar waktu. Di akhir tutorial perbandingan String Java ini saya juga akan membahas mengapa operator "==" tidak berfungsi saat membandingkan string Java.

Opsi 1: Perbandingan Java String dengan metode equals Sebagian besar waktu (mungkin 95% dari waktu) Saya membandingkan string dengan metode equals dari kelas Java String, seperti ini:

if (string1.equals(string2))

Metode String sama dengan ini melihat dua string Java, dan jika mereka berisi string karakter yang sama persis, mereka dianggap sama.

Melihat contoh perbandingan String cepat dengan metode equals, jika tes berikut dijalankan, dua string tidak akan dianggap sama karena karakternya tidak persis sama (kasus karakter berbeda):

String string1 = "foo";
String string2 = "FOO";

if (string1.equals(string2))
{
    // this line will not print because the
    // java string equals method returns false:
    System.out.println("The two strings are the same.")
}

Tetapi, ketika dua string berisi string karakter yang sama persis, metode equals akan mengembalikan true, seperti dalam contoh ini:

String string1 = "foo";
String string2 = "foo";

// test for equality with the java string equals method
if (string1.equals(string2))
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

Opsi 2: Perbandingan string dengan metode equalsIgnoreCase

Dalam beberapa tes perbandingan string, Anda ingin mengabaikan apakah string dalam huruf besar atau kecil. Saat Anda ingin menguji string Anda untuk kesetaraan dengan cara case-insensitive ini, gunakan metode equalsIgnoreCase dari kelas String, seperti ini:

String string1 = "foo";
String string2 = "FOO";

 // java string compare while ignoring case
 if (string1.equalsIgnoreCase(string2))
 {
     // this line WILL print
     System.out.println("Ignoring case, the two strings are the same.")
 }

Opsi 3: Perbandingan Java String dengan metode compareTo

Ada juga yang ketiga, cara yang kurang umum untuk membandingkan string Java, dan itu dengan metode StringTemper banding kelas. Jika dua string persis sama, metode compareTo akan mengembalikan nilai 0 (nol). Berikut adalah contoh singkat dari apa yang tampak seperti pendekatan perbandingan String ini:

String string1 = "foo bar";
String string2 = "foo bar";

// java string compare example
if (string1.compareTo(string2) == 0)
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

Sementara saya sedang menulis tentang konsep persamaan di Jawa, penting untuk dicatat bahwa bahasa Jawa mencakup metode yang sama dengan di kelas dasar Java Object. Setiap kali Anda membuat objek Anda sendiri dan Anda ingin memberikan cara untuk melihat apakah dua instance objek Anda "sama", Anda harus menimpa (dan mengimplementasikan) metode yang sama dengan ini di kelas Anda (dengan cara yang sama bahasa Java menyediakan perilaku persamaan / perbandingan ini dalam metode String sama dengan).

Anda mungkin ingin melihat ini ==, .equals (), compareTo (), dan bandingkan ()

Fungsi:

public float simpleSimilarity(String u, String v) {
    String[] a = u.split(" ");
    String[] b = v.split(" ");

    long correct = 0;
    int minLen = Math.min(a.length, b.length);

    for (int i = 0; i < minLen; i++) {
        String aa = a[i];
        String bb = b[i];
        int minWordLength = Math.min(aa.length(), bb.length());

        for (int j = 0; j < minWordLength; j++) {
            if (aa.charAt(j) == bb.charAt(j)) {
                correct++;
            }
        }
    }

    return (float) (((double) correct) / Math.max(u.length(), v.length()));
}

Uji:

String a = "This is the first string.";

String b = "this is not 1st string!";

// for exact string comparison, use .equals

boolean exact = a.equals(b);

// For similarity check, there are libraries for this
// Here I'll try a simple example I wrote

float similarity = simple_similarity(a,b);

The ==cek Operator jika dua referensi menunjuk ke objek yang sama atau tidak. .equals()periksa konten string yang sebenarnya (nilai).

Perhatikan bahwa .equals()metode ini milik kelas Object(kelas super semua kelas). Anda perlu menimpanya sesuai kebutuhan kelas Anda, tetapi untuk String sudah diterapkan, dan memeriksa apakah dua string memiliki nilai yang sama atau tidak.

• Kasus 1

  String s1 = "Stack Overflow";
  String s2 = "Stack Overflow";
  s1 == s2;      //true
  s1.equals(s2); //true

  Alasan: String literal yang dibuat tanpa null disimpan di kumpulan String di area permgen heap. Jadi titik s1 dan s2 baik untuk objek yang sama di kolam renang.

• Kasus 2

  String s1 = new String("Stack Overflow");
  String s2 = new String("Stack Overflow");
  s1 == s2;      //false
  s1.equals(s2); //true

  Alasan: Jika Anda membuat objek String menggunakan newkata kunci, ruang terpisah dialokasikan untuk itu di heap.

==membandingkan nilai referensi objek sedangkan equals()metode yang ada di java.lang.Stringkelas membandingkan konten Stringobjek (dengan objek lain).

Saya pikir ketika Anda mendefinisikan StringAnda mendefinisikan sebuah objek. Jadi, Anda perlu menggunakan .equals(). Saat Anda menggunakan tipe data primitif yang Anda gunakan ==tetapi dengan String(dan objek apa pun) yang harus Anda gunakan .equals().

Jika equals()metode hadir di java.lang.Objectkelas, dan diharapkan untuk memeriksa kesetaraan keadaan objek! Itu artinya, isi benda. Sedangkan== operator diharapkan memeriksa instance objek yang sebenarnya sama atau tidak.

Contoh

Pertimbangkan dua variabel referensi yang berbeda, str1dan str2:

str1 = new String("abc");
str2 = new String("abc");

Jika Anda menggunakan equals()

System.out.println((str1.equals(str2))?"TRUE":"FALSE");

Anda akan mendapatkan output seperti TRUEjika Anda gunakan ==.

System.out.println((str1==str2) ? "TRUE" : "FALSE");

Sekarang Anda akan mendapatkan FALSEoutput sebagai, karena keduanya str1dan str2menunjuk ke dua objek yang berbeda walaupun keduanya berbagi konten string yang sama. Itu karena new String()objek baru dibuat setiap saat.

Operator == selalu dimaksudkan untuk perbandingan referensi objek , sedangkan metode kelas String .equals () diganti untuk perbandingan konten :

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // It prints false (reference comparison)
System.out.println(s1.equals(s2)); // It prints true (content comparison)

Semua objek dijamin memiliki .equals()metode karena Objek berisi metode .equals(),, yang mengembalikan boolean. Adalah tugas subclass untuk menimpa metode ini jika definisi definisi lebih lanjut diperlukan. Tanpa itu (yaitu menggunakan ==) hanya alamat memori yang diperiksa antara dua objek untuk kesetaraan. String menimpa .equals()metode ini dan alih-alih menggunakan alamat memori, String mengembalikan perbandingan string pada level karakter untuk kesetaraan.

Catatan utama adalah bahwa string disimpan dalam satu kumpulan benjolan sehingga setelah sebuah string dibuat, string tersebut selamanya disimpan dalam sebuah program di alamat yang sama. String tidak berubah, mereka tidak berubah. Inilah sebabnya mengapa itu adalah ide yang buruk untuk menggunakan penggabungan string biasa jika Anda memiliki jumlah serius pemrosesan string yang harus dilakukan. Sebagai gantinya Anda akan menggunakan StringBuilderkelas yang disediakan. Ingat pointer ke string ini dapat berubah dan jika Anda tertarik untuk melihat apakah dua pointer itu sama ==akan menjadi cara yang baik untuk pergi. String sendiri tidak.

Anda juga dapat menggunakan compareTo()metode ini untuk membandingkan dua String. Jika hasil compareTo adalah 0, maka kedua string sama, jika tidak, string yang dibandingkan tidak sama.

Yang ==membandingkan referensi dan tidak membandingkan string yang sebenarnya. Jika Anda memang membuat setiap string menggunakan new String(somestring).intern()maka Anda dapat menggunakan ==operator untuk membandingkan dua string, jika tidak sama dengan () atau metode compareTo hanya dapat digunakan.

Di Jawa, ketika operator “==” digunakan untuk membandingkan 2 objek, ia memeriksa untuk melihat apakah objek merujuk ke tempat yang sama di memori. Dengan kata lain, itu memeriksa untuk melihat apakah 2 nama objek pada dasarnya referensi ke lokasi memori yang sama.

Kelas Java String benar-benar menimpa implementasi default equals () di kelas Object - dan itu menimpa metode sehingga hanya memeriksa nilai-nilai string, bukan lokasi mereka di memori. Ini berarti bahwa jika Anda memanggil metode equals () untuk membandingkan 2 objek String, maka selama urutan karakter sebenarnya sama, kedua objek dianggap sama.

The ==cek Operator jika dua string yang persis objek yang sama.

The .equals()metode cek jika dua string memiliki nilai yang sama.