Panduan untuk hashCode () di Java

1. Gambaran keseluruhan

Hashing adalah konsep asas sains komputer.

Di Java, algoritma hash yang cekap berada di belakang beberapa koleksi paling popular yang kami ada - seperti HashMap (untuk melihat secara mendalam di HashMap , sila baca artikel ini) dan HashSet.

Dalam artikel ini, kita akan menumpukan pada bagaimana hashCode () berfungsi, bagaimana ia berfungsi menjadi koleksi dan bagaimana menerapkannya dengan betul.

**2. Penggunaan hashCode () dalam Struktur Data**

Operasi paling mudah pada koleksi boleh menjadi tidak efisien dalam situasi tertentu.

Sebagai contoh, ini mencetuskan carian linier yang sangat tidak berkesan untuk senarai saiz besar:

List words = Arrays.asList("Welcome", "to", "Baeldung"); if (words.contains("Baeldung")) { System.out.println("Baeldung is in the list"); }

Java menyediakan sejumlah struktur data untuk menangani masalah ini secara khusus - sebagai contoh, beberapa implementasi antara muka Peta adalah tabel hash.

Apabila menggunakan jadual hash, koleksi ini mengira nilai hash untuk kunci yang diberikan menggunakan Kodcincang () kaedah dan menggunakan nilai ini secara dalaman untuk menyimpan data - supaya operasi akses adalah lebih cekap.

**3. Memahami Bagaimana hashCode () Berfungsi**

Secara sederhana , hashCode () mengembalikan nilai integer, yang dihasilkan oleh algoritma hashing.

Objek yang sama (mengikut sama dengan () ) mesti mengembalikan kod hash yang sama. Tidak diperlukan objek yang berbeza untuk mengembalikan kod hash yang berbeza.

Kontrak umum hashCode () menyatakan:

Setiap kali ia dipanggil pada objek yang sama lebih dari sekali semasa pelaksanaan aplikasi Java, hashCode () harus secara konsisten mengembalikan nilai yang sama, dengan syarat tidak ada maklumat yang digunakan dalam perbandingan yang sama pada objek yang diubah. Nilai ini tidak perlu tetap konsisten dari satu pelaksanaan aplikasi ke pelaksanaan aplikasi lain yang sama

Sekiranya dua objek sama dengan kaedah sama (Objek) , maka memanggil kaedah hashCode () pada setiap dua objek mesti menghasilkan nilai yang sama

Tidak diperlukan bahawa jika dua objek tidak sama menurut kaedah sama (java.lang.Object) , maka memanggil kaedah hashCode pada setiap dua objek mesti menghasilkan hasil bilangan bulat yang berbeza. Walau bagaimanapun, pemaju harus sedar bahawa menghasilkan keputusan bilangan bulat yang berbeza untuk objek yang tidak sama meningkatkan prestasi jadual hash

"Sebanyak praktis, kaedah hashCode () yang ditentukan oleh kelas Object tidak mengembalikan bilangan bulat yang berbeza untuk objek yang berbeza. (Ini biasanya dilaksanakan dengan mengubah alamat internal objek menjadi bilangan bulat, tetapi teknik pelaksanaan ini tidak diperlukan oleh bahasa pengaturcaraan JavaTM.) "

**4. Pelaksanaan hashCode Naive ()**

Sebenarnya sangat mudah untuk mempunyai pelaksanaan hashCode () naif yang mematuhi sepenuhnya kontrak di atas.

Untuk menunjukkan ini, kami akan menentukan contoh kelas Pengguna yang menggantikan pelaksanaan lalai kaedah:

public class User { private long id; private String name; private String email; // standard getters/setters/constructors @Override public int hashCode() { return 1; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null) return false; if (this.getClass() != o.getClass()) return false; User user = (User) o; return id == user.id && (name.equals(user.name) && email.equals(user.email)); } // getters and setters here }

The pengguna kelas menyediakan pelaksanaan adat untuk kedua-dua sama dengan () dan Kodcincang () yang mematuhi sepenuhnya kepada kontrak masing-masing. Lebih-lebih lagi, tidak ada yang tidak sah dengan mempunyai hashCode () mengembalikan nilai tetap.

Walau bagaimanapun, pelaksanaan ini menurunkan fungsi jadual hash pada asasnya sifar, kerana setiap objek akan disimpan dalam baldi tunggal yang sama.

Dalam konteks ini, pencarian jadual hash dilakukan secara linier dan tidak memberi kita kelebihan nyata - lebih lanjut mengenai perkara ini di bahagian 7.

5. Meningkatkan Pelaksanaan hashCode ()

Mari perbaiki sedikit pelaksanaan hashCode () dengan memasukkan semua bidang kelas Pengguna sehingga dapat menghasilkan hasil yang berbeza untuk objek yang tidak sama:

@Override public int hashCode() { return (int) id * name.hashCode() * email.hashCode(); }

Algoritma hash asas ini pasti jauh lebih baik daripada yang sebelumnya, kerana ia mengira kod hash objek dengan hanya mengalikan kod hash nama dan bidang e - mel dan id .

Secara umum, kita dapat mengatakan bahawa ini adalah pelaksanaan hashCode () yang wajar , selagi kita memastikan pelaksanaan sama () sama dengannya.

**6. Pelaksanaan hashCode Standard ()**

Semakin baik algoritma hash yang kita gunakan untuk mengira kod hash, semakin baik prestasi jadual hash.

Mari kita lihat pelaksanaan "standard" yang menggunakan dua nombor prima untuk menambahkan lebih banyak keunikan pada kod hash yang dikira:

@Override public int hashCode() { int hash = 7; hash = 31 * hash + (int) id; hash = 31 * hash + (name == null ? 0 : name.hashCode()); hash = 31 * hash + (email == null ? 0 : email.hashCode()); return hash; }

Walaupun sangat mustahak untuk memahami peranan yang dimainkan oleh kaedah hashCode () dan sama () , kami tidak perlu menerapkannya dari awal setiap kali, kerana kebanyakan IDE dapat menghasilkan implementasi hashCode () dan sama () dan sejak Java 7, kami mendapat kaedah utiliti Objects.hash () untuk hashing yang selesa:

Objects.hash(name, email)

IntelliJ IDEA menghasilkan pelaksanaan berikut:

@Override public int hashCode() { int result = (int) (id ^ (id >>> 32)); result = 31 * result + name.hashCode(); result = 31 * result + email.hashCode(); return result; }

Dan Eclipse menghasilkan yang satu ini:

@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((email == null) ? 0 : email.hashCode()); result = prime * result + (int) (id ^ (id >>> 32)); result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; }

Sebagai tambahan kepada implementasi hashCode () berdasarkan IDE di atas , juga memungkinkan untuk menghasilkan pelaksanaan yang efisien secara automatik, misalnya menggunakan Lombok. Dalam kes ini, kebergantungan lombok-maven mesti ditambahkan ke pom.xml :

 org.projectlombok lombok-maven 1.16.18.0 pom

It's now enough to annotate the User class with @EqualsAndHashCode:

@EqualsAndHashCode public class User { // fields and methods here }

Similarly, if we want Apache Commons Lang's HashCodeBuilder class to generate a hashCode() implementation for us, the commons-lang Maven dependency must be included in the pom file:

 commons-lang commons-lang 2.6

And hashCode() can be implemented like this:

public class User { public int hashCode() { return new HashCodeBuilder(17, 37). append(id). append(name). append(email). toHashCode(); } }

In general, there's no universal recipe to stick to when it comes to implementing hashCode(). We highly recommend reading Joshua Bloch's Effective Java, which provides a list of thorough guidelines for implementing efficient hashing algorithms.

What can be noticed here is that all those implementations utilize number 31 in some form – this is because 31 has a nice property – its multiplication can be replaced by a bitwise shift which is faster than the standard multiplication:

31 * i == (i << 5) - i

7. Handling Hash Collisions

The intrinsic behavior of hash tables raises up a relevant aspect of these data structures: even with an efficient hashing algorithm, two or more objects might have the same hash code, even if they're unequal. So, their hash codes would point to the same bucket, even though they would have different hash table keys.

This situation is commonly known as a hash collision, and various methodologies exist for handling it, with each one having their pros and cons. Java's HashMap uses the separate chaining method for handling collisions:

“When two or more objects point to the same bucket, they're simply stored in a linked list. In such a case, the hash table is an array of linked lists, and each object with the same hash is appended to the linked list at the bucket index in the array.

In the worst case, several buckets would have a linked list bound to it, and the retrieval of an object in the list would be performed linearly.”

Hash collision methodologies show in a nutshell why it's so important to implement hashCode() efficiently.

Java 8 brought an interesting enhancement to HashMap implementation – if a bucket size goes beyond the certain threshold, the linked list gets replaced with a tree map. This allows achieving O(logn) look up instead of pessimistic O(n).

8. Creating a Trivial Application

To test the functionality of a standard hashCode() implementation, let's create a simple Java application that adds some User objects to a HashMap and uses SLF4J for logging a message to the console each time the method is called.

Here's the sample application's entry point:

public class Application { public static void main(String[] args) { Map users = new HashMap(); User user1 = new User(1L, "John", "[email protected]"); User user2 = new User(2L, "Jennifer", "[email protected]"); User user3 = new User(3L, "Mary", "[email protected]"); users.put(user1, user1); users.put(user2, user2); users.put(user3, user3); if (users.containsKey(user1)) { System.out.print("User found in the collection"); } } }

And this is the hashCode() implementation:

public class User { // ... public int hashCode() { int hash = 7; hash = 31 * hash + (int) id; hash = 31 * hash + (name == null ? 0 : name.hashCode()); hash = 31 * hash + (email == null ? 0 : email.hashCode()); logger.info("hashCode() called - Computed hash: " + hash); return hash; } }

The only detail worth stressing here is that each time an object is stored in the hash map and checked with the containsKey() method, hashCode() is invoked and the computed hash code is printed out to the console:

[main] INFO com.baeldung.entities.User - hashCode() called - Computed hash: 1255477819 [main] INFO com.baeldung.entities.User - hashCode() called - Computed hash: -282948472 [main] INFO com.baeldung.entities.User - hashCode() called - Computed hash: -1540702691 [main] INFO com.baeldung.entities.User - hashCode() called - Computed hash: 1255477819 User found in the collection

9. Conclusion

It's clear that producing efficient hashCode() implementations often requires a mixture of a few mathematical concepts, (i.e. prime and arbitrary numbers), logical and basic mathematical operations.

Regardless, it's entirely possible to implement hashCode() effectively without resorting to these techniques at all, as long as we make sure the hashing algorithm produces different hash codes for unequal objects and is consistent with the implementation of equals().

Seperti biasa, semua contoh kod yang ditunjukkan dalam artikel ini terdapat di GitHub.