60%

OFF

Cyber Monday: Get all Java Courses for Lifetime – yours forever. Claim Your
Discount.
Sale ends in 0d : 1hrs : 37mins : 29s

Programiz
Courses
Tutorials
Examples

Search tutorials and examples

Learn Java Interactively
Java Introduction
Java Flow Control
Java Arrays
Java OOP (I)
Java OOP (II)
Java OOP (III)
Java Exception Handling
Java List
Java Queue
Java Map
Java Map Interface
Java HashMap
Java LinkedHashMap
Java WeakHashMap
Java EnumMap
Java SortedMap Interface
Java NavigableMap Interface
Java TreeMap
Java ConcurrentMap Interface
Java ConcurrentHashMap
Java Set
Java I/O Streams
Java Reader/Writer
Additional Topics
Related Topics
Java HashMap putIfAbsent()
Java HashMap replaceAll()
Java HashMap isEmpty()
Java HashMap clear()
Java HashMap putAll()
Java HashMap entrySet()
Java HashMap
In this tutorial, we will learn about the Java HashMap class and its various
operations with the help of examples.

The HashMap class of the Java collections framework provides the functionality of
the hash table data structure.

It stores elements in key/value pairs. Here, keys are unique identifiers used to
associate each value on a map.

The HashMap class implements the Map interface.

Java HashMap implements Map interface
Java HashMap Implementation
Create a HashMap
In order to create a hash map, we must import the java.util.HashMap package first.
Once we import the package, here is how we can create hashmaps in Java.

// hashMap creation with 8 capacity and 0.6 load factor

HashMap<K, V> numbers = new HashMap<>();
In the above code, we have created a hashmap named numbers. Here, K represents the
key type and V represents the type of values. For example,

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

Here, the type of keys is String and the type of values is Integer.

Example 1: Create HashMap in Java

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);
}
}
Run Code
Output

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

In the above example, we have created a HashMap named languages.

Here, we have used the put() method to add elements to the hashmap. We will learn
more about the put() method later in this tutorial.

Basic Operations on Java HashMap

The HashMap class provides various methods to perform different operations on
hashmaps. We will look at some commonly used arraylist operations in this tutorial:

Add elements
Access elements
Change elements
Remove elements
1. Add elements to a HashMap
To add a single element to the hashmap, we use the put() method of the HashMap
class. For example,

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);
}
}
Run Code
Output

Initial HashMap: {}
HashMap after put(): {One=1, Two=2, Three=3}
In the above example, we have created a HashMap named numbers. Here, we have used
the put() method to add elements to numbers.

Notice the statement,

numbers.put("One", 1);
Here, we are passing the String value One as the key and Integer value 1 as the
value to the put() method.

Recommended Readings

Java HashMap put()

Java HashMap putAll()
Java HashMap putIfAbsent()
2. Access HashMap Elements
We can use the get() method to access the value from the hashmap. For example,

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);
}
}
Run Code
Output

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

Value at index 1: Java
In the above example, notice the expression,

languages.get(1);
Here, the get() method takes the key as its argument and returns the corresponding
value associated with the key.

We can also access the keys, values, and key/value pairs of the hashmap as set
views using keySet(), values(), and entrySet() methods respectively. For example,
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());
}
}
Run Code
Output

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

Keys: [1, 2, 3]
Values: [Java, Python, JavaScript]
Key/Value mappings: [1=Java, 2=Python, 3=JavaScript]
In the above example, we have created a hashmap named languages. Here, we are
accessing the keys, values, and key/value mappings from the hashmap.

Recommended Readings

Java HashMap get()

Java Hashmap getOrDefault()
Java HashMap keySet()
Java HashMap values()
Java HashMap entrySet()
3. Change HashMap Value
We can use the replace() method to change the value associated with a key in a
hashmap. For example,

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);
}
}
Run Code
Output

Original HashMap: {1=Java, 2=Python, 3=JavaScript}

HashMap using replace(): {1=Java, 2=C++, 3=JavaScript}
In the above example, we have created a hashmap named languages. Notice the
expression,

languages.replace(2, "C++");
Here, we are changing the value referred to by key 2 with the new value C++.

The HashMap class also provides some variations of the replace() method. To learn
more, visit

Java HashMap replace()

Java HashMap replaceAll()
4. Remove HashMap Elements
To remove elements from a hashmap, we can use the remove() method. For example,

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);

}
}
Run Code
Output

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

Removed value: Python
Updated HashMap: {1=Java, 3=JavaScript}
Here, the remove() method takes the key as its parameter. It then returns the value
associated with the key and removes the entry.

We can also remove the entry only under certain conditions. For example,

remove(2, "C++");
Here, the remove() method only removes the entry if the key 2 is associated with
the value C++. Since 2 is not associated with C++, it doesn't remove the entry.

To learn more, visit Java HashMap remove().

Other Methods of HashMap

Method Description
clear() removes all mappings from the HashMap
compute() computes a new value for the specified key
computeIfAbsent() computes value if a mapping for the key is not present
computeIfPresent() computes a value for mapping if the key is present
merge() merges the specified mapping to the HashMap
clone() makes the copy of the HashMap
containsKey() checks if the specified key is present in Hashmap
containsValue() checks if Hashmap contains the specified value
size() returns the number of items in HashMap
isEmpty() checks if the Hashmap is empty
Iterate through a HashMap
To iterate through each entry of the hashmap, we can use Java for-each loop. We can
iterate through keys only, vales only, and key/value mapping. For example,

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(", ");
}
}
}
Run Code
Output

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

Keys: 1, 2, 3,
Values: Java, Python, JavaScript,
Entries: 1=Java, 2=Python, 3=JavaScript,
Note that we have used the Map.Entry in the above example. It is the nested class
of the Map interface that returns a view (elements) of the map.
We first need to import the java.util.Map.Entry package in order to use this class.

This nested class returns a view (elements) of the map.

Creating HashMap from Other Maps

In Java, we can also create a hashmap from other maps. For example,

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);
}
}
Run Code
Output

TreeMap: {Four=4, Two=2}

HashMap: {Two=2, Three=3, Four=4}
In the above example, we have created a TreeMap named evenNumbers. Notice the
expression,

numbers = new HashMap<>(evenNumbers)

Here, we are creating a HashMap named numbers using the TreeMap. To learn more
about treemap, visit Java TreeMap.

Note: While creating a hashmap, we can include optional parameters: capacity and
load factor. For example,

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

Here,

8 (capacity is 8) - This means it can store 8 entries.

0.6f (load factor is 0.6) - This means whenever our hash table is filled by 60%,
the entries are moved to a new hash table double the size of the original hash
table.
If the optional parameters not used, then the default capacity will be 16 and the
default load factor will be 0.75.

Previous Tutorial:
Java Map Interface
Next Tutorial:
Java LinkedHashMap
Share on:
Did you find this article helpful?
Related Tutorials
Java Library
Java HashMap putIfAbsent()

Java Library

Java HashMap replaceAll()

Java Library

Java HashMap isEmpty()

Java Library

Java HashMap clear()

Learn Java Interactively

Join our newsletter for the latest updates.

Enter Email Address*
Join

Tutorials
Python 3 Tutorial
JavaScript Tutorial
SQL Tutorial
C Tutorial
Java Tutorial
Kotlin Tutorial
C++ Tutorial
Swift Tutorial
C# Tutorial
Go Tutorial
DSA Tutorial
Examples
Python Examples
JavaScript Examples
C Examples
Java Examples
Kotlin Examples
C++ Examples
Company
About
Advertising
Privacy Policy
Terms & Conditions
Contact
Blog
Youtube
Apps
Learn Python
Learn C Programming
Learn Java
© Parewa Labs Pvt. Ltd. All rights reserved.