I've telah menggunakan ==
operator dalam program saya untuk membandingkan semua senar saya sejauh ini.
Namun, aku berlari ke bug, mengubah salah satu dari mereka menjadi .sama dengan()
bukan, dan itu tetap bug.
Adalah ==
buruk? Ketika harus ini dan harus itu tidak dapat digunakan? Apa's perbedaan?
==
tes untuk referensi kesetaraan (apakah mereka adalah objek yang sama).
.sama dengan()
tes untuk nilai kesetaraan (apakah mereka secara logis "sama").
Objects.equals() pemeriksaan untuk null
sebelum memanggil .sama dengan()
sehingga anda don't harus (tersedia sebagai JDK7, juga tersedia di Jambu).
String.contentEquals() membandingkan isi dari String
dengan isi CharSequence
(tersedia sejak Java 1.5).
Akibatnya, jika anda ingin menguji apakah dua string memiliki nilai yang sama anda mungkin akan ingin menggunakan benda-Benda.sama dengan()
.
// 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 menggunakan benda-Benda.sama dengan()
. Di rare situasi di mana anda *tahu * anda're berhadapan dengan magang string, anda dapat gunakan ==
.
Dari JLS 3.10.5. String Literal:
Selain itu, sebuah string literal selalu mengacu sama ** contoh kelas
String
. Hal ini karena string literal - atau, lebih umum, string itu adalah nilai konstan ekspresi (§15.28) - "magang" sehingga untuk berbagi yang unik contoh, menggunakan metodeString.magang
.
Contoh-contoh serupa juga dapat ditemukan di JLS 3.10.5-1.
==
tes referensi objek, .sama dengan()
menguji nilai-nilai string.
Kadang-kadang tampak seolah-olah ==
membandingkan nilai-nilai, karena Java tidak beberapa behind-the-scenes hal-hal yang membuat yakin identik dalam baris string yang benar-benar objek yang sama.
Misalnya:
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";
Tapi hati-hati dari nulls!
==
menangani null
string baik-baik saja, tapi memanggil .sama dengan()
dari null string 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 bahwa fooString1
dapat null, memberitahu pembaca bahwa dengan menulis
System.out.print(fooString1 != null && fooString1.equals("bar"));
Berikut ini pendek, tapi itu kurang jelas sehingga memeriksa null (dari Jawa 7):
System.out.print(Objects.equals(fooString1, "bar"));
==
membandingkan Objek referensi.
.sama dengan()
membandingkan nilai-nilai String.
Kadang-kadang ==
memberikan ilusi membandingkan nilai-nilai String, seperti dalam kasus berikut:
String a="Test";
String b="Test";
if(a==b) ===> true
Hal ini karena ketika anda membuat setiap String literal, JVM pertama pencarian untuk yang literal String renang, dan jika menemukan kecocokan yang sama referensi akan diberikan untuk String baru. Karena ini, kita mendapatkan:
(a==b) ===> benar
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 yang akan diberikan kepada b
, jadi b
akan diberikan referensi di heap, bukan String di kolam renang.
Sekarang a
adalah menunjuk ke String dalam String renang sambil b
adalah menunjuk ke String di heap. Karena yang kami dapatkan:
if(a==b) ===> palsu.
String Pool
"test" <-------------------- a
Heap
"test" <-------------------- b
Sementara .sama dengan()
selalu membandingkan nilai String sehingga memberikan 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 .sama dengan()
selalu lebih baik.
String di Jawa yang berubah. Itu berarti setiap kali anda mencoba untuk mengubah/mengubah string anda mendapatkan sebuah instance baru. Anda tidak dapat mengubah string asli. Hal ini telah dilakukan sehingga ini string contoh-contoh yang dapat di-cache. Sebuah program yang khas mengandung banyak string referensi dan caching hal ini dapat mengurangi jejak memori dan meningkatkan kinerja program.
Ketika menggunakan == operator untuk perbandingan string anda tidak membandingkan isi string, tapi benar-benar membandingkan alamat memori. Jika mereka berdua sama ini akan mengembalikan nilai true dan false jika tidak. Padahal sama dalam string membandingkan string isi.
Jadi pertanyaannya adalah jika semua string yang di-cache dalam sistem, bagaimana bisa ==
return false sedangkan sama dengan return true? Nah, hal ini mungkin. Jika anda membuat string baru seperti String str = new String("Test")
anda akhirnya membuat string baru di cache bahkan jika cache sudah berisi string yang memiliki konten yang sama. Singkatnya "MyString" == new String("MyString")
akan selalu kembali palsu.
Jawa juga berbicara tentang fungsi intern() yang dapat digunakan pada string untuk membuat ini bagian dari cache jadi "MyString" == new String("MyString").magang()
akan kembali benar.
Catatan: == operator jauh lebih cepat daripada sama hanya karena anda membandingkan dua alamat memori, tetapi anda perlu memastikan bahwa kode isn't membuat String baru kasus dalam kode. Jika tidak, anda akan mengalami 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 memahami mengapa. It's karena ==
dibandingkan hanya membandingkan referensi; masa sama dengan()
metode apakah karakter-per-karakter perbandingan isi.
Ketika anda menelepon baru untuk a
dan b
, masing-masing mendapat referensi baru yang menunjuk ke "anu"
dalam tabel string. Referensi yang berbeda, namun isinya sama.
Ya, itu's buruk...
==
berarti bahwa anda dua string referensi yang sama persis dengan objek. Anda mungkin pernah mendengar bahwa hal ini terjadi karena Jawa membuat semacam literal meja (yang tidak), tapi itu tidak selalu terjadi. Beberapa string yang dimuat dalam cara yang berbeda, dibangun dari string lain, dll., jadi anda tidak harus mengasumsikan bahwa dua identik string disimpan di lokasi yang sama.
Sama dengan melakukan perbandingan nyata untuk anda.
Ya, ==
buruk untuk membandingkan String (benda yang benar-benar, kecuali jika anda tahu mereka're kanonik). ==
hanya membandingkan objek referensi. .sama dengan()
tes untuk kesetaraan. Untuk String, sering mereka'll sama tapi seperti yang anda've ditemukan, bahwa's tidak dijamin selalu.
Jawa memiliki String kolam renang di bawah Jawa yang mengelola alokasi memori untuk objek String. Lihat String kolam Renang di pulau Jawa
Ketika anda check (membandingkan) dua benda dengan menggunakan ==
operator membandingkan alamat kesetaraan ke string-kolam renang. Jika dua objek String yang memiliki alamat yang sama dengan referensi maka kembali benar
, jika palsu
. Tapi jika anda ingin membandingkan isi dari dua objek String maka anda harus mengganti sama dengan
metode.
sama dengan
sebenarnya adalah metode kelas Objek, tetapi Diganti ke kelas String dan definisi baru diberikan yang membandingkan isi dari objek.
Example:
stringObjectOne.equals(stringObjectTwo);
Tapi pikiran itu hal kasus String. Jika anda ingin kasus sensitif membandingkan maka anda harus pergi untuk equalsIgnoreCase metode dari class String.
Let's Melihat:
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 zacherates.
Tapi apa yang dapat anda lakukan adalah untuk memanggil magang()
pada non-literal string.
Dari zacherates contoh:
// ... but they are not the same object
new String("test") == "test" ==> false
Jika anda magang non-literal String kesetaraan adalah benar
new String("test").intern() == "test" ==> true
==
membandingkan referensi objek dalam Java, dan itu tidak terkecuali untuk String
benda-benda.
Untuk membandingkan isi sebenarnya dari benda-benda (termasuk String
), salah satu harus menggunakan sama dengan
metode.
Jika perbandingan dua String
benda-benda yang menggunakan ==
ternyata menjadi benar
, itu karena String
benda-benda yang diinternir, dan Mesin Virtual Java ini memiliki beberapa titik referensi ke contoh yang sama dari String
. Kita tidak harus berharap bahwa membandingkan satu String
objek yang mengandung isi yang sama seperti yang lain String
objek menggunakan ==
untuk mengevaluasi sebagai benar
.
.sama dengan()
membandingkan data dalam kelas (dengan asumsi fungsi diimplementasikan).
==
membandingkan penunjuk lokasi (lokasi objek dalam memori).
==
mengembalikan true jika kedua benda (TIDAK BERBICARA TENTANG PRIMITIF) arahkan ke objek yang SAMA misalnya.
.sama dengan()
mengembalikan true jika dua objek yang berisi data yang sama sama dengan()
Versus ==
di Jawa
Yang mungkin dapat membantu anda.
==
melakukan referensi kesetaraan memeriksa, apakah 2 benda (string dalam kasus ini) mengacu pada objek yang sama di memori.
Masa sama dengan()
metode akan memeriksa apakah isi atau negara dari 2 objek yang sama.
Jelas ==
lebih cepat, tapi akan (mungkin) memberikan hasil yang palsu dalam banyak kasus jika anda hanya ingin memberitahu jika 2 `String tahan teks yang sama.
Pasti menggunakan sama dengan()
adalah metode yang direkomendasikan.
Don't khawatir tentang kinerja. Beberapa hal yang dapat mendorong menggunakan String.sama dengan()
:
String.sama dengan()
pemeriksaan terlebih dahulu untuk referensi kesetaraan (menggunakan ==
), dan jika 2 string yang sama dengan referensi, tidak ada lagi perhitungan dilakukan!String.sama dengan()
berikutnya akan memeriksa panjang dari string. Ini juga merupakan operasi cepat karena String
toko kelas panjang string, tidak perlu untuk menghitung karakter atau kode poin. Jika panjang berbeda, tidak ada pemeriksaan lanjutan yang dilakukan, kita tahu mereka tidak bisa sama.Ketika semua dikatakan dan dilakukan, bahkan jika kita memiliki jaminan bahwa string adalah magang, menggunakan sama dengan()
metode ini masih belum overhead yang satu mungkin berpikir, pasti cara yang direkomendasikan. Jika anda ingin efisien reference check, kemudian gunakan enums di mana hal ini dijamin oleh spesifikasi bahasa dan implementasi yang sama enum nilai akan menjadi objek yang sama (by reference).
Jika anda're seperti saya, ketika saya pertama kali mulai menggunakan Java, saya ingin menggunakan "==" operator untuk menguji apakah dua String kasus yang sama, tapi untuk lebih baik atau lebih buruk, yang's tidak cara yang benar untuk melakukannya di Jawa.
Dalam tutorial ini saya'll menunjukkan beberapa cara yang berbeda untuk benar membandingkan Jawa string, dimulai dengan pendekatan yang saya gunakan sebagian besar waktu. Pada akhir ini Jawa perbandingan String tutorial I'll juga membahas mengapa "==" operator doesn't bekerja ketika membandingkan Jawa string.
Opsi 1: Java String perbandingan dengan sama dengan metode Sebagian besar waktu (mungkin 95% dari waktu) saya membandingkan string dengan sama dengan metode Java class String, seperti ini:
if (string1.equals(string2))
String ini sama dengan metode terlihat di dua Jawa string, dan jika mereka berisi sama persis karakter string, mereka dianggap sama.
Mengambil melihat pada perbandingan String misalnya dengan sama dengan metode, jika mengikuti tes lari, dua string tidak akan dianggap sama karena karakter-karakter yang tidak persis sama (kasus karakter yang 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.")
}
Tapi, ketika dua string yang berisi sama persis karakter string, sama dengan metode yang akan kembali benar, 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 equalsIgnoreCase metode
Di beberapa perbandingan string tes anda'll ingin mengabaikan apakah string huruf besar atau huruf kecil. Bila anda ingin menguji string untuk kesetaraan dalam hal ini case-sensitive, gunakan equalsIgnoreCase metode dari class 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: Jawa perbandingan String dengan method compareTo
Ada juga yang ketiga, kurang umum cara untuk membandingkan Jawa string, dan yang's dengan String kelas compareTo metode. Jika kedua string adalah persis sama, compareTo metode ini akan mengembalikan nilai 0 (nol). Berikut ini's contoh singkat dari apa yang ini perbandingan String pendekatan terlihat seperti:
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 aku'm menulis tentang konsep kesetaraan di Jawa, it's penting untuk dicatat bahwa bahasa Jawa termasuk aplikasi yang sama dengan metode dalam basa Jawa kelas Objek. Setiap kali anda're menciptakan sendiri objek dan anda ingin menyediakan sarana untuk melihat apakah dua contoh dari objek yang "sama", anda harus meng-override (dan menerapkan) ini sama dengan metode di kelas anda (dengan cara yang sama bahasa Jawa menyediakan kesetaraan ini/perbandingan perilaku dalam String yang sama dengan metode).
Anda mungkin ingin melihat ini ==, .sama dengan(), compareTo(), dan membandingkan()
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()));
}
Tes:
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 ==
operator memeriksa apakah dua titik referensi ke objek yang sama atau tidak. .sama dengan()
check for string yang sebenarnya isi (value).
Perhatikan bahwa .sama dengan()
metode milik kelas Objek
(super class dari semua kelas). Anda perlu mengganti sesuai kelas anda kebutuhan, tapi untuk String itu sudah dilaksanakan, dan memeriksa apakah dua string memiliki nilai yang sama atau tidak.
String s1 = "Stack Overflow"; String s2 = "Stack Overflow"; s1 == s2; //benar s1.equals(s2); //benar
Alasan: String literal dibuat tanpa null disimpan dalam String renang di permgen daerah timbunan. Jadi baik s1 dan s2 menunjuk ke object yang sama di kolam renang.
String s1 = new String("Stack Overflow"); String s2 = new String("Stack Overflow"); s1 == s2; //false s1.equals(s2); //benar
Alasan: Jika anda membuat sebuah objek String yang menggunakan baru
kata kunci ruang terpisah dialokasikan di heap.
Saya berpikir bahwa ketika anda mendefinisikan String
anda mendefinisikan sebuah objek. Jadi, anda perlu menggunakan .sama dengan()
. Ketika anda menggunakan primitif tipe data yang anda gunakan ==
tapi dengan String
(dan setiap objek) anda harus menggunakan .sama dengan()
.
Jika sama dengan()
metode ini hadir di pulau jawa.lang.Objekkelas, dan diharapkan untuk memeriksa kesetaraan keadaan benda-benda! Artinya, isi dari benda-benda. Sedangkan
==` operator diharapkan untuk memeriksa objek yang sebenarnya kasus yang sama atau tidak.
Contoh
Pertimbangkan dua referensi yang berbeda variabel, str1
dan str2
:
str1 = new String("abc");
str2 = new String("abc");
Jika anda menggunakan sama dengan()
System.out.println((str1.equals(str2))?"TRUE":"FALSE");
Anda akan mendapatkan output sebagai TRUE
jika anda menggunakan ==
.
System.out.println((str1==str2) ? "TRUE" : "FALSE");
Sekarang anda akan mendapatkan PALSU
sebagai output, karena kedua str1
dan str2
yang menunjuk ke dua objek yang berbeda meskipun keduanya dari mereka berbagi string yang sama konten. Hal ini karena new String()
sebuah objek baru diciptakan setiap saat.
Operator == selalu dimaksudkan untuk referensi objek perbandingan, sedangkan String kelas .sama dengan() metode ditimpa untuk konten perbandingan:
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)