HashMap erstellen

Um eine Hash-Map zu erstellen, müssen wir den java.util.HashMap importieren Paket zuerst. Sobald wir das Paket importiert haben, können wir Hashmaps in Java wie folgt erstellen.

// hashMap creation with 8 capacity and 0.6 load factor
HashMap<K, V> numbers = new HashMap<>();

Im obigen Code haben wir eine Hashmap namens numbers erstellt . Hier, K steht für den Schlüsseltyp und V stellt die Art der Werte dar. Zum Beispiel

HashMap<String, Integer> numbers = new HashMap<>();

Hier die Art der Schlüssel ist String und die Art der Werte ist Integer .

Beispiel 1:HashMap in Java erstellen

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    // create a hashmap
    HashMap<String, Integer> languages = new HashMap<>();

    // add elements to hashmap
    languages.put("Java", 8);
    languages.put("JavaScript", 1);
    languages.put("Python", 3);
    System.out.println("HashMap: " + languages);
  }
}

Ausgabe

HashMap: {Java=8, JavaScript=1, Python=3}

Im obigen Beispiel haben wir einen HashMap erstellt benannte Sprachen .

Hier haben wir den put() verwendet Methode zum Hinzufügen von Elementen zur Hashmap. Wir werden mehr über die put() erfahren -Methode später in diesem Tutorial.

Grundlegende Operationen auf Java HashMap

Die HashMap -Klasse stellt verschiedene Methoden bereit, um verschiedene Operationen auf Hashmaps auszuführen. Wir werden uns in diesem Tutorial einige häufig verwendete Arraylist-Operationen ansehen:

• Elemente hinzufügen
• Access-Elemente
• Elemente ändern
• Elemente entfernen

1. Elemente zu einer HashMap hinzufügen

Um der Hashmap ein einzelnes Element hinzuzufügen, verwenden wir den put() Methode des HashMap Klasse. Zum Beispiel

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    // create a hashmap
    HashMap<String, Integer> numbers = new HashMap<>();

    System.out.println("Initial HashMap: " + numbers);
    // put() method to add elements
    numbers.put("One", 1);
    numbers.put("Two", 2);
    numbers.put("Three", 3);
    System.out.println("HashMap after put(): " + numbers);
  }
}

Ausgabe

Initial HashMap: {}
HashMap after put(): {One=1, Two=2, Three=3}

Im obigen Beispiel haben wir einen HashMap erstellt benannte Zahlen . Hier haben wir den put() verwendet Methode zum Hinzufügen von Elementen zu Zahlen.

Beachten Sie die Anweisung,

numbers.put("One", 1);

Hier passieren wir die String Wert Eins als Schlüssel und Integer Wert 1 als Wert für put() Methode.

Empfohlene Lektüre

• Java HashMap put()
• Java HashMap putAll()
• Java HashMap putIfAbsent()

2. Zugriff auf HashMap-Elemente

Wir können den get() verwenden -Methode, um auf den Wert aus der Hashmap zuzugreifen. Zum Beispiel

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // get() method to get value
    String value = languages.get(1);
    System.out.println("Value at index 1: " + value);
  }
}

Ausgabe

HashMap: {1=Java, 2=Python, 3=JavaScript}
Value at index 1: Java

Beachten Sie im obigen Beispiel den Ausdruck,

languages.get(1);

Hier die get() Methode nimmt den Schlüssel als Argument und gibt den entsprechenden Wert zurück dem Schlüssel zugeordnet.

Wir können auch auf die Schlüssel zugreifen , Werte und Schlüssel/Wert Paare der Hashmap als Set Views mit keySet() , values() , und entrySet() Methoden bzw. Zum Beispiel

import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    HashMap<Integer, String> languages = new HashMap<>();

    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // return set view of keys
    // using keySet()
    System.out.println("Keys: " + languages.keySet());

    // return set view of values
    // using values()
    System.out.println("Values: " + languages.values());

    // return set view of key/value pairs
    // using entrySet()
    System.out.println("Key/Value mappings: " + languages.entrySet());
  }
}

Ausgabe

HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: [1, 2, 3]
Values: [Java, Python, JavaScript]
Key/Value mappings: [1=Java, 2=Python, 3=JavaScript]

Im obigen Beispiel haben wir eine Hashmap mit dem Namen languages erstellt . Hier greifen wir auf die Schlüssel zu , Werte und Schlüssel/Wert Zuordnungen aus der Hashmap.

Empfohlene Lektüre

• Java HashMap get()
• Java-Hashmap getOrDefault()
• Java HashMap keySet()
• Java HashMap-Werte()
• Java HashMap entrySet()

3. HashMap-Wert ändern

Wir können den replace() verwenden -Methode zum Ändern des Werts, der einem Schlüssel in einer Hashmap zugeordnet ist. Zum Beispiel

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("Original HashMap: " + languages);

    // change element with key 2
    languages.replace(2, "C++");
    System.out.println("HashMap using replace(): " + languages);
  }
}

Ausgabe

Original HashMap: {1=Java, 2=Python, 3=JavaScript}
HashMap using replace(): {1=Java, 2=C++, 3=JavaScript}

Im obigen Beispiel haben wir eine Hashmap mit dem Namen languages erstellt . Beachten Sie den Ausdruck,

languages.replace(2, "C++");

Hier ändern wir den Wert, auf den sich der Schlüssel 2 bezieht mit dem neuen Wert C++ .

Der HashMap -Klasse bietet auch einige Variationen von replace() Methode. Um mehr zu erfahren, besuchen Sie

• Java-HashMap-Ersetzung()
• Java HashMap replaceAll()

4. HashMap-Elemente entfernen

Um Elemente aus einer Hashmap zu entfernen, können wir die Methode remove() verwenden. Zum Beispiel

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // remove element associated with key 2
    String value = languages.remove(2);
    System.out.println("Removed value: " + value);

    System.out.println("Updated HashMap: " + languages);
  }
}

Ausgabe

HashMap: {1=Java, 2=Python, 3=JavaScript}
Removed value: Python
Updated HashMap: {1=Java, 3=JavaScript}

Hier der remove() Methode nimmt den Schlüssel als seinen Parameter. Es gibt dann den Wert zurück dem Schlüssel zugeordnet und entfernt den Eintrag .

Auch können wir den Eintrag nur unter bestimmten Voraussetzungen entfernen. Zum Beispiel

remove(2, "C++");

Hier der remove() Methode entfernt nur den Eintrag wenn die Taste 2 ist dem Wert C++ zugeordnet . Seit 2 ist nicht mit C++ verknüpft , der Eintrag wird nicht entfernt.

Um mehr zu erfahren, besuchen Sie Java HashMap remove().

Andere Methoden von HashMap

Eine HashMap durchlaufen

Um jeden Eintrag der Hashmap zu durchlaufen, können wir Java for-each-Schleife verwenden. Wir können nur Schlüssel durchlaufen , nur Täler und Schlüssel/Wert-Zuordnung . Zum Beispiel

import java.util.HashMap;
import java.util.Map.Entry;

class Main {
  public static void main(String[] args) {

    // create a HashMap
    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // iterate through keys only
    System.out.print("Keys: ");
    for (Integer key : languages.keySet()) {
      System.out.print(key);
      System.out.print(", ");
    }

    // iterate through values only
    System.out.print("\nValues: ");
    for (String value : languages.values()) {
      System.out.print(value);
      System.out.print(", ");
    }
    
    // iterate through key/value entries
    System.out.print("\nEntries: ");
    for (Entry<Integer, String> entry : languages.entrySet()) {
      System.out.print(entry);
      System.out.print(", ");
    }
  }
}

Ausgabe

HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: 1, 2, 3,
Values: Java, Python, JavaScript,        
Entries: 1=Java, 2=Python, 3=JavaScript,

Beachten Sie, dass wir den Map.Entry verwendet haben im obigen Beispiel. Es ist die verschachtelte Klasse von Map Schnittstelle, die eine Ansicht (Elemente) der Karte zurückgibt.

Wir müssen zuerst den java.util.Map.Entry importieren Paket, um diese Klasse zu verwenden.

Diese verschachtelte Klasse gibt eine Ansicht (Elemente) der Karte zurück.

HashMap aus anderen Karten erstellen

In Java können wir auch eine Hashmap aus anderen Maps erstellen. Zum Beispiel

import java.util.HashMap;
import java.util.TreeMap;

class Main {
  public static void main(String[] args) {

    // create a treemap
    TreeMap<String, Integer> evenNumbers = new TreeMap<>();
    evenNumbers.put("Two", 2);
    evenNumbers.put("Four", 4);
    System.out.println("TreeMap: " + evenNumbers);

    // create hashmap from the treemap
    HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
    numbers.put("Three", 3);
    System.out.println("HashMap: " + numbers);
  }
}

Ausgabe

TreeMap: {Four=4, Two=2}
HashMap: {Two=2, Three=3, Four=4}

Im obigen Beispiel haben wir einen TreeMap erstellt mit dem Namen evenNumbers . Beachten Sie den Ausdruck,

numbers = new HashMap<>(evenNumbers)

Hier erstellen wir einen HashMap benannte Nummern mit dem TreeMap . Um mehr über Treemaps zu erfahren, besuchen Sie Java TreeMap.

Hinweis :Beim Erstellen einer Hashmap können wir optionale Parameter einschließen:Kapazität und Ladefaktor . Zum Beispiel

HashMap<K, V> numbers = new HashMap<>(8, 0.6f);

Hier,

• 8 (Kapazität ist 8) - Das bedeutet, dass 8 Einträge gespeichert werden können.
• 0,6f (Ladefaktor ist 0,6) - Das bedeutet, wenn unsere Hash-Tabelle zu 60 % gefüllt ist, werden die Einträge in eine neue Hash-Tabelle verschoben, die doppelt so groß ist wie die ursprüngliche Hash-Tabelle.

Wenn die optionalen Parameter nicht verwendet werden, dann die Standard-Kapazität wird 16 sein und den standardmäßigen Lastfaktor beträgt 0,75 .