java "sama" dan "==" Kesamaan
Pertama, mari kita bicara sebentar tentang "setara" dan "=="
== Operasi membandingkan apakah nilai dari dua variabel sama untuk tipe data dasar.
Untuk variabel referensi, itu berarti apakah alamat yang disimpan dalam tumpukan adalah sama,
Apakah konten di tumpukan sama?
Apakah dua variabel yang diwakili oleh operasi yang sama adalah referensi ke objek yang sama,
Artinya, apakah konten di tumpukannya sama.
Singkatnya, == membandingkan alamat 2 objek, sedangkan sama dengan membandingkan konten 2 objek.
Izinkan saya memperkenalkan kelas string secara singkat
Kelas string juga disebut urutan karakter yang tidak dapat diubah
String menggunakan nilai arang akhir pribadi [] untuk mewujudkan penyimpanan string. Dengan kata lain, setelah objek string dibuat, konten string yang disimpan dalam objek ini tidak dapat dimodifikasi. Kelas String memiliki metode pembuatan khusus, yaitu untuk menggunakan "" Kutipan Ganda untuk membuatnya. Misalnya, string baru ("123") sebenarnya membuat 2 objek string, satu dibuat oleh "123" melalui "" kutipan ganda, dan yang lainnya dibuat oleh baru. Namun, periode yang mereka buat berbeda, satu adalah periode kompilasi dan yang lainnya adalah periode yang dijalankan. Java membebani operator + untuk jenis string, dan Anda dapat langsung menggunakan + untuk menggabungkan dua string. Memanggil metode intern () dari kelas string selama runtime dapat secara dinamis menambahkan objek ke kumpulan string.
Bedakan antara dua metode membuat objek string "" dan baru ()
String adalah data pengemasan khusus. Dapat digunakan:
String str1 = string baru ("123"); string str2 = "123";Buat dua bentuk
Yang pertama adalah menggunakan baru () untuk membuat objek baru, yang akan disimpan di heap. Objek baru dibuat setiap kali dipanggil. (Sebenarnya dua, seperti yang disebutkan di atas, tetapi setelah keberadaan "123" di kolam konstan, "123" yang baru tidak akan lagi dibuat di kolam konstan)
Tipe kedua adalah untuk pertama -tama membuat variabel STR ke objek kelas string di tumpukan, dan kemudian menggunakan referensi simbolik untuk mengetahui apakah ada "ABC" di kumpulan string konstan. Jika tidak, simpan "ABC" ke dalam kolam konstanta tali dan biarkan STR ke "ABC". Jika sudah ada "ABC", maka langsung biarkan STR ke "ABC".
Kita harus memperhatikan saat ini
Di satu sisi, metode penulisan pertama bermanfaat dan menghemat ruang memori. Pada saat yang sama, dapat meningkatkan kecepatan berjalan program sampai batas tertentu, karena JVM akan secara otomatis memutuskan apakah perlu membuat objek baru berdasarkan situasi aktual data dalam tumpukan. Untuk kode string str = string baru ("123");, objek baru dibuat dalam tumpukan terlepas dari apakah nilai string sama atau tidak, apakah perlu membuat objek baru, sehingga meningkatkan beban pada program. Di sisi lain, ketika kami mendefinisikan kelas menggunakan format seperti string str = "123";, kami selalu menerima begitu saja bahwa kami membuat objek STR dari kelas string.
Objek mungkin belum dibuat! Dan mungkin hanya menunjuk ke objek yang telah dibuat sebelumnya. Hanya melalui metode baru () kita dapat memastikan bahwa objek baru dibuat setiap saat.
Silakan lihat contoh berikut
paket teststring; testString kelas publik {public static void main (string [] args) {string a = "123"; String b = "123"; System.out.println (a == b); System.out.println (A.Equals (b)); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Konten dari dua objek yang direferensikan dalam heap adalah sama, jadi a.equals (b) benar */ string c = string baru ("1234"); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Sama seperti d heap, jadi c.Equals (d) adalah benar */ string e = "a1"; String f = "a" +1; System.out.println (e == f); System.out.println (E.Equals (f)); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * Java sendiri memiliki operator tertentu yang berlebihan, tetapi Anda tidak dapat menggunakan kelebihan operator yang mendefinisikan dirinya sendiri "H"; System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Terima kasih telah membaca, saya harap ini dapat membantu Anda. Terima kasih atas dukungan Anda untuk situs ini!