Masalah komparatif di Java adalah yang sangat mendasar dan mudah dibingungkan. Hari ini saya akan meringkas dan mengatur ringkasan dan pengaturan beberapa poin yang rawan kesalahan, berharap itu akan membantu untuk studi dan wawancara semua orang.
1. Perbedaan antara == dan sama ()
Pertama -tama, kita perlu mengetahui perbedaan antara == dan sama (). Tanda == selalu dibandingkan dengan nilai alamat. Untuk tipe data dasar, == Perbandingan sebenarnya apakah nilai variabel sama, sedangkan untuk tipe data referensi, nilai alamat dibandingkan. Apa yang perlu Anda perhatikan secara khusus di sini adalah jenis string, yang mudah diterima begitu saja == dan mudah membuat kesalahan. Metode Equals () adalah metode di kelas objek. Kita tahu bahwa semua kelas di Java akan mewarisi kelas objek secara default, sehingga objek kelas akan memiliki metode Equals (). Metode Equals () di kelas objek ditunjukkan pada gambar di bawah ini:
Seperti yang dapat dilihat dari kode sumber, lapisan yang mendasari metode Equals () di kelas objek juga menggunakan ==, sehingga sebenarnya nilai alamat. Jadi jika kita ingin menggunakan metode Equals () untuk perbandingan lain, kita perlu mengganti metode Equals ().
2. Jenis Data Dasar dan Jenis Pengemasan
Kita semua tahu bahwa byte, pendek, int, panjang, boolean, char, ganda, dan float adalah tipe data dasar, dan variabel yang mereka nyatakan disimpan dalam memori tumpukan. Variabel yang ditentukan oleh jenis pengemasan yang sesuai (byte, pendek, integer, panjang, boolean, karakter, ganda) ada dalam memori heap. Untuk tipe data dasar, perbandingannya relatif sederhana, yaitu, gunakan == untuk menentukan apakah mereka sama, dan gunakan <,>, <=,> = untuk membandingkan ukuran. Tetapi untuk jenis pengemasan, ini sedikit berbeda.
Pertama, untuk menentukan apakah itu sama, lihat hasil eksekusi dari kode berikut:
Paket DailyTest; impor org.junit.test;/*** Ringkasan komparatif di java* @author yrr*/kelas publik javacomparetest {/*** Jenis integer penilaian sama*/@test public void test01 () {int n3 = 48; System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n8); // false system.out.println (n7 == n3); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System n6); NullpointException}/*** Jenis penilaian panjang sama*/@test public void test02 () {// Catatan di sini bahwa ketika menggunakan definisi panjang, L atau L tidak diperlukan, tetapi ketika menggunakan panjang, jika tidak kesalahan akan dilaporkan // tambahkan dalam konstruksi untuk menunjukkan perbedaan lama N3 = 48L; System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- N1); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (n4 == N5); // Saat menggunakan metode long.intvalue (), Anda perlu memperhatikan untuk memverifikasi apakah itu nol untuk mencegah nullpointException}}Untuk hasil eksekusi di atas, penjelasan berikut dibuat:
Pertama, untuk metode baru, kami mendeklarasikan bilangan bulat atau objek panjang. Karena objek baru membuka sepotong ruang di tumpukan, bahkan jika nilai keduanya sama, untuk ==, nilai alamat dibandingkan, jadi false akan dikembalikan. Untuk kelas pembungkus tipe data dasar, metode Equals () telah ditulis ulang, dan ukuran numerik akan dibandingkan, sehingga metode Equals () dapat digunakan untuk menilai berdasarkan ukuran numerik. Mengenai masalah membandingkan variabel integer dengan variabel int, kami akan menemukan bahwa nilai perbandingan juga didasarkan pada ukuran numerik. Ini karena ketika membandingkan, tipe integer secara otomatis dibuka dan dikonversi ke tipe int. Penjelasan dari tiga poin pertama berlaku untuk semua jenis kemasan. Untuk metode penugasan langsung, dua variabel integer dengan nilai 48 dinilai benar oleh tanda ==, tetapi ketika nilainya 128, itu salah. Ini karena di bagian bawah, untuk integer n1 = 48;, metode penugasan langsung sebenarnya memanggil metode integer.value (). Kita dapat melihat secara singkat kode sumber metode integer.value (), seperti yang ditunjukkan pada gambar di bawah ini:
Kita dapat melihat bahwa ada penilaian IF di sini. Ketika input I berada dalam kisaran [-128, 127], dikembalikan langsung dari array integercache. Oleh karena itu, untuk nilai -nilai dalam kisaran ini, nilai alamat yang sesuai dengan array ini dikembalikan, jadi menggunakan tanda == untuk menilai true akan dikembalikan. Apa yang tidak dalam kisaran ini adalah objek yang baru, jadi salah akan dikembalikan. Kesimpulan ini berlaku untuk byte, pendek, integer, dan tipe yang panjang (jika Anda tertarik, Anda dapat memeriksa kode sumber dari metode nilai () yang sesuai), karena ruang lingkup tipe byte adalah [-128, 127], jadi untuk tipe byte, menggunakan == tidak berbeda dengan setara ().
Untuk perbandingan ukuran, tidak ada masalah menggunakan>, <, <, <=,> =, dan mereka akan secara otomatis dibatalkan. Tetapi kami biasanya merekomendasikan menggunakan dua cara berikut untuk membandingkan ukuran:
Hubungi metode xxxValue () untuk mengubahnya menjadi tipe data dasar untuk perbandingan. Di kelas pembungkus, metode compareto () ditulis ulang. Dengan melihat kode sumber compareTo (), Anda dapat melihat bahwa pada kenyataannya, penggunaan yang mendasarinya juga dikonversi menjadi tipe data dasar yang sesuai dengan secara otomatis unboxing dan kemudian membandingkannya.
2. Perbandingan objek java
Dengan pengantar di atas, lebih mudah untuk membandingkan objek. Prinsip -prinsipnya sama.
1. Perbandingan tipe string
Perlu dicatat bahwa tipe string tidak dapat digunakan secara langsung>, <=,> =, dan <, dan akan melaporkan pengecualian kompilasi.
Paket DailyTest; Impor org.junit.test;/*** Ringkasan komparatif di java* @author yrr*/kelas publik javacomparetest {@test void test03 () {string s1 = string baru ("123"); String s2 = string baru ("123"); System.out.println (S1 == S2); // false system.out.println (s1.equals (s2)); String s3 = "234"; String s4 = "234"; System.out.println (S3 == S4); // true system.out.println (s3.equals (s4)); // true //system.out.println(s1 <= s3); // Operator <tidak terdefinisi untuk tipe argumen java.lang.string, java.lang.string system.out.println (s1.compareto (s3) <0); //BENAR }}2. Perbandingan objek kelas
Kesimpulan dari objek kelas adalah sama, tetapi dibandingkan dengan tipe data dasar dan tipe string, itu sedikit lebih rumit.
Menurut aturan tertentu, untuk menentukan apakah kedua objek itu sama, metode setara () perlu ditulis ulang di kelas yang dihakimi. Kode contoh adalah sebagai berikut:
Paket DailyTest; Impor org.junit.test;/*** Ringkasan komparatif di java* @author yrr*/kelas publik javacomparetest {@test public void test04 () {orang p1 = orang baru ("yrr", 18); Orang p2 = orang baru ("yrr", 18); System.out.println (p1 == P2); // false system.out.println (p2.equals (p1)); // true}} class person {private string name; usia bilangan bulat pribadi; orang publik () {} orang publik (nama string, usia integer) {this.name = name; this.age = usia; } public string getName () {return name; } getage integer publik () {usia kembali; } @Override public boolean sama (objek obj) {orang orang = (orang) obj; return name.equals (person.getName ()) && age.equals (person.getage ()); }}Dan jika Anda ingin membandingkan ukuran dua objek (ini juga merupakan pertanyaan wawancara umum), ada dua cara:
Kelas yang sebanding mengimplementasikan antarmuka yang sebanding, dan mengesampingkan metode compareto () untuk mendefinisikan kelas yang mengimplementasikan antarmuka pembanding atau menggunakan kelas internal untuk mengganti metode perbandingan (): yang pertama didefinisikan pada kelas yang sebanding, sedangkan yang terakhir didefinisikan di luar kelas yang sebanding. Melalui perbedaan ini, kelebihan dan kekurangan keduanya juga jelas. Yang pertama sederhana, tetapi membutuhkan modifikasi dari kelas yang dibandingkan, sedangkan yang terakhir tidak perlu memodifikasi kode asli, yang lebih fleksibel.
Metode pertama, kode sampel adalah sebagai berikut:
Paket DailyTest; Impor org.junit.test;/*** Ringkasan komparatif di java* @author yrr*/kelas publik javacomparetest {@test public void test5 () {person p1 = orang baru ("yrr", 18); Orang p2 = orang baru ("wx", 19); System.out.println (p1.compareto (p2) <0); }} class Person mengimplementasikan yang sebanding dengan <son> {private string name; usia bilangan bulat pribadi; orang publik () {} orang publik (nama string, usia integer) {this.name = name; this.age = usia; } getage integer publik () {usia kembali; } @Override public int compareto (orang o) {return this.getage () - o.getage (); }}Metode kedua, kode sampel adalah sebagai berikut:
package comparator;import java.util.Arrays;import java.util.Comparator;public class MyComparator { public static void main(String[] args) { User[] users = new User[] { new User("u1001", 25), new User("u1002", 20), new User("u1003", 21) }; Arrays.sort (pengguna, pembanding baru <User> () {@Override Public int Compare (User O1, User O2) {return o1.getage () - o2.getage ();}}); untuk (int i = 0; i <Users.length; i ++) {user user = user [i]; System.out.println (user.getId () + "" + user.getage ()); }}} kelas pengguna {private string id; usia int pribadi; pengguna publik (ID string, int usia) {this.id = id; this.age = usia; } public int getage () {usia kembali; } public void setage (int usia) {this.age = usia; } public String getId () {return id; } public void setId (string id) {this.id = id; }}Di atas adalah konten yang relevan dari pertanyaan perbandingan Java yang saya katakan kali ini. Jika Anda memiliki pertanyaan lain, Anda dapat mendiskusikannya di area komentar di bawah ini. Terima kasih atas dukungan Anda.