Anleitung zu hashCode () in Java

1. Übersicht

Hashing ist ein grundlegendes Konzept der Informatik.

In Java stehen effiziente Hashing-Algorithmen hinter einigen der beliebtesten verfügbaren Sammlungen - wie der HashMap (für einen detaillierten Blick auf HashMap können Sie diesen Artikel lesen ) und dem HashSet.

In diesem Artikel konzentrieren wir uns darauf, wie hashCode () funktioniert, wie es in Sammlungen abgespielt wird und wie es korrekt implementiert wird.

2. Verwendung von hashCode () in Datenstrukturen

Die einfachsten Operationen für Sammlungen können in bestimmten Situationen ineffizient sein.

Dies löst beispielsweise eine lineare Suche aus, die für Listen mit großen Größen äußerst ineffektiv ist:

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

Java bietet eine Reihe von Datenstrukturen, um dieses Problem speziell zu behandeln. Beispielsweise sind mehrere Implementierungen der Map- Schnittstelle Hash-Tabellen.

Bei Verwendung einer Hash-Tabelle berechnen diese Sammlungen den Hash-Wert für einen bestimmten Schlüssel mithilfe der hashCode () -Methode und verwenden diesen Wert intern zum Speichern der Daten, sodass Zugriffsvorgänge wesentlich effizienter sind.

3. Verstehen, wie hashCode () funktioniert

Einfach ausgedrückt, gibt hashCode () einen ganzzahligen Wert zurück, der von einem Hashing-Algorithmus generiert wird.

Objekte, die gleich sind (entsprechend ihrem equals () ), müssen denselben Hashcode zurückgeben. Es ist nicht erforderlich, dass verschiedene Objekte unterschiedliche Hash-Codes zurückgeben.

Der Generalvertrag von hashCode () besagt:

  • Immer wenn es während der Ausführung einer Java-Anwendung mehr als einmal für dasselbe Objekt aufgerufen wird, muss hashCode () konsistent denselben Wert zurückgeben, sofern keine Informationen geändert werden, die für gleiche Vergleiche für das Objekt verwendet werden. Dieser Wert muss von einer Ausführung einer Anwendung zu einer anderen Ausführung derselben Anwendung nicht konsistent bleiben
  • Wenn zwei Objekte gemäß der Methode equals (Object) gleich sind, muss der Aufruf der Methode hashCode () für jedes der beiden Objekte denselben Wert erzeugen
  • Es ist nicht erforderlich, dass der Aufruf der hashCode- Methode für jedes der beiden Objekte unterschiedliche ganzzahlige Ergebnisse liefern muss , wenn zwei Objekte gemäß der Methode equals (java.lang.Object) ungleich sind . Entwickler sollten sich jedoch bewusst sein, dass das Erzeugen eindeutiger ganzzahliger Ergebnisse für ungleiche Objekte die Leistung von Hash-Tabellen verbessert

„Soweit dies vernünftigerweise praktikabel ist, gibt die von class Object definierte hashCode () -Methode unterschiedliche Ganzzahlen für unterschiedliche Objekte zurück. (Dies wird normalerweise implementiert, indem die interne Adresse des Objekts in eine Ganzzahl konvertiert wird. Diese Implementierungstechnik wird jedoch von der JavaTM-Programmiersprache nicht benötigt.) ”

4. Eine naive hashCode () - Implementierung

Es ist eigentlich ganz einfach, eine naive hashCode () - Implementierung zu haben, die den oben genannten Vertrag vollständig einhält.

Um dies zu demonstrieren, definieren wir eine Beispiel- Benutzerklasse , die die Standardimplementierung der Methode überschreibt:

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 }

Die User- Klasse bietet benutzerdefinierte Implementierungen für equals () und hashCode () , die den jeweiligen Verträgen vollständig entsprechen. Darüber hinaus ist es nicht unzulässig, wenn hashCode () einen festen Wert zurückgibt .

Diese Implementierung verschlechtert jedoch die Funktionalität von Hash-Tabellen auf grundsätzlich Null, da jedes Objekt in demselben einzelnen Bucket gespeichert würde.

In diesem Zusammenhang wird eine Hash-Tabellensuche linear durchgeführt und bietet keinen wirklichen Vorteil - mehr dazu in Abschnitt 7.

5. Verbesserung der Implementierung von hashCode ()

Lassen Sie uns die aktuelle Implementierung von hashCode () ein wenig verbessern , indem wir alle Felder der User- Klasse einbeziehen, damit unterschiedliche Ergebnisse für ungleiche Objekte erzielt werden können:

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

Dieser grundlegende Hashing-Algorithmus ist definitiv viel besser als der vorherige, da er den Hash-Code des Objekts berechnet, indem nur die Hash-Codes der Namen- und E-Mail- Felder und der ID multipliziert werden .

Im Allgemeinen können wir sagen, dass dies eine vernünftige Implementierung von hashCode () ist , solange wir die Implementierung von equals () damit konsistent halten .

6. Standard hashCode () Implementations

Je besser der Hashing-Algorithmus ist, mit dem wir Hash-Codes berechnen, desto besser ist die Leistung von Hash-Tabellen.

Werfen wir einen Blick auf eine „Standard“ -Implementierung, die zwei Primzahlen verwendet, um berechneten Hash-Codes noch mehr Eindeutigkeit zu verleihen:

@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; }

Während es wichtig ist, die Rollen zu verstehen, die die Methoden hashCode () und equals () spielen, müssen wir sie nicht jedes Mal von Grund auf neu implementieren, da die meisten IDEs benutzerdefinierte Implementierungen von hashCode () und equals () generieren können und seit Java 7 Wir haben eine Objects.hash () - Dienstprogrammmethode für komfortables Hashing:

Objects.hash(name, email)

IntelliJ IDEA generiert die folgende Implementierung:

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

Und Eclipse produziert dieses:

@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; }

Zusätzlich zu den oben genannten IDE-basierten hashCode () - Implementierungen ist es auch möglich, automatisch eine effiziente Implementierung zu generieren, beispielsweise mit Lombok. In diesem Fall muss die lombok-maven-Abhängigkeit zu pom.xml hinzugefügt werden :

 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().

Wie immer sind alle in diesem Artikel gezeigten Codebeispiele auf GitHub verfügbar.