Die Anleitung zu Java HashMap

• Map
• TreeMap
• WeakHashMap
• LinkedHashMap
• IdentityHashMap
• ConcurrentHashMap
• ConcurrentSkipListMap
• EnumMap

• HashMap enthaltet die Paaren Schlüssel und Wert.
• Es kann einen Schlüssel null und viele Werten null haben.
• HashMap behält die Reihenfolge der Schlüssel nicht bei.
• Es funktioniert mit der Hashing Technik. (mehr Erklärungen über diese Technik in folgenden Teil lesen).

package org.o7planning.hashmap.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class HashMapEx1 {
 
    public static void main(String[] args) {
        Map<String, String> phonebook = new HashMap<String, String>();
 
        phonebook.put("01000005", "Tom");
        phonebook.put("01000002", "Jerry");
        phonebook.put("01000003", "Tom");
        phonebook.put("01000004", "Donald");
        
        Set<String> phoneNumbers = phonebook.keySet();
 
        for (String phoneNumber : phoneNumbers) {
            String name = phonebook.get(phoneNumber);
            
            System.out.println("Phone Number: " + phoneNumber + " ==> Name: " + name);
        }
    }
}

Phone Number: 01000004 ==> Name: Donald
Phone Number: 01000003 ==> Name: Tom
Phone Number: 01000005 ==> Name: Tom
Phone Number: 01000002 ==> Name: Jerry

• Die Anleitung zu Java Map

Sehen Sie mehr: Die Klasse WeakHashMap ist eine speichersparende Variante der Klasse HashMap. Die nicht wirklich benötigen Mappings werden von Java Garbage Collector automatisch entfernt)

• Die Anleitung zu Java WeakHashMap

• Java System.identityHashCode, Object.hashCode und Object.equals verstehen

HashMap<K,V> verwaltet ein Array der Objekte Node<K,V>. Dieser Array wird durch einen anderen Array mit der größeren Größe ersetzt wenn alle Elementen dem Wert zugewiesen werden.

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

Die Klasse Node<K,V> fasst 4 Felder (field) um. Und der Feld next ist ein Referenz auf das nächste Objekt Node, Es kann keine nächste Elemente im Array sein.

static class Node<K,V> implements Map.Entry<K,V> {
    int hashcode;
    K key;
    V value;
    Node<K,V> next;
}

HashMap stellt sicher, dass Node in demselben hashcode aufeinanderfolgende Referenz haben, damit es alle Node mit dem gleichen angegebenen hashcode finden kann.

HashMap.put(key,value)

Bei dem Aufruf der Methode HashMap.put(key,value) wird HashMap die Node suchen, die die Bedingung node.hashcode == hash(key) erfüllen. Wenn nicht gefunden, wird ein neues Objekt Node dem Array zugewiesen. (Sehen Sie die folgende Abbildung)

Umgekehrt wird HashMap die aufeinanderfolgende Node schnell zu definieren, die die Bedingung node.hashcode == hash(key) zu erfüllen und schränkt den Umfang der suchenden Node nach key ein.

• Wenn der dem key entsprechende Node gefunden wird, wird der neue Wert Node.value zugewiesen.
• Im Gegenteil ein neues Objekt Node wird erstellt und dem Array zugewiesen (siehe Abbildung unten).

HashMap.get(key)

Wenn die Methode HashMap.get(key) aufgerufen wird, identifiziert HashMap schnell aufeinanderfolgende Node, die die Bedingung node.hashcode == hash(key) erfüllen, wodurch der Umfang des zu suchenden Node nach key eingeschränkt wird. Als nächstes sucht es nach Node nach key und gibt node.value zurück, wenn es gefunden wird, andernfalls gibt es null zurück.

HashMap.remove(key)

Schlussfolgerung: Die Methode Object.hashcode() gibt hashcode eines Objekt zurück, der standardmäßig von der JVM generiert wird und sehr selten duplikat ist. Die Unterklassen der Klasse Object können das Methode überschreiben um die benutzerdefinierten hashcode zurückzugeben.

HashMap benutzt hashing technique um seine Leistung zu verbessern. Weil das Vergleichen von 2 Zahlen immer schneller als das Vergleichen von 2 Objekte ist.