In this article, you will learn important Java HashMap methods with examples.
put() Method
We can use a put() method to add key-value pairs to the HashMap.import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Orange", 20);
map.put("Banana", 30);
System.out.println(map);
}
}
{Apple=10, Banana=30, Orange=20}
putAll() Method
The putAll() method is used to copy all of the mappings from the specified map to this map.
Here is an example of using the putAll() method in a HashMap:
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// Creating two HashMap objects
HashMap<String, Integer> studentMarks1 = new HashMap<>();
HashMap<String, Integer> studentMarks2 = new HashMap<>();
// Using put() method to add key-value pairs to first HashMap
studentMarks1.put("Alice", 85);
studentMarks1.put("Bob", 90);
// Using put() method to add key-value pairs to second HashMap
studentMarks2.put("Charlie", 95);
studentMarks2.put("David", 80);
// Displaying the initial HashMaps
System.out.println("Initial HashMap 1: " + studentMarks1);
System.out.println("Initial HashMap 2: " + studentMarks2);
// Using putAll() method to put all mappings from second HashMap to the first
studentMarks1.putAll(studentMarks2);
// Displaying the updated HashMaps
System.out.println("Updated HashMap 1: " + studentMarks1);
System.out.println("Unchanged HashMap 2: " + studentMarks2);
}
}
Output:
Initial HashMap 1: {Alice=85, Bob=90}
Initial HashMap 2: {Charlie=95, David=80}
Updated HashMap 1: {Alice=85, Bob=90, Charlie=95, David=80}
Unchanged HashMap 2: {Charlie=95, David=80}
In this example, we create two HashMap objects named studentMarks1 and studentMarks2 that map students' names (Strings) to their marks (Integers). We use the put() method to add different key-value pairs to each HashMap. Then, we use the putAll() method to put all mappings from studentMarks2 to studentMarks1. This does not affect studentMarks2. After each putAll() operation, we print out the contents of both HashMaps.
get() Method
The get() method takes the key as an argument and returns the corresponding value. To access elements in a HashMap, you can use the get() method:
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Orange", 20);
map.put("Banana", 30);
// Access the value corresponding to the key "Apple"
Integer appleValue = map.get("Apple");
System.out.println("Value for 'Apple': " + appleValue);
// Access the value corresponding to the key "Orange"
Integer orangeValue = map.get("Orange");
System.out.println("Value for 'Orange': " + orangeValue);
// Access the value corresponding to the key "Banana"
Integer bananaValue = map.get("Banana");
System.out.println("Value for 'Banana': " + bananaValue);
}
}
Value for 'Apple': 10
Value for 'Orange': 20
Value for 'Banana': 30
remove() Method
To remove an element from the HashMap, use the remove() method. The remove() method removes the mapping for a key from this map if it is present.
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// Create a HashMap object
HashMap<String, Integer> map = new HashMap<>();
// Add key-value pairs to the HashMap
map.put("Apple", 10);
map.put("Orange", 20);
map.put("Banana", 30);
System.out.println("Original HashMap: " + map);
// Remove the key-value pair with key "Apple"
map.remove("Apple");
System.out.println("HashMap after removing 'Apple': " + map);
// Remove the key-value pair with key "Orange"
map.remove("Orange");
System.out.println("HashMap after removing 'Orange': " + map);
}
}
Original HashMap: {Orange=20, Banana=30, Apple=10}
HashMap after removing 'Apple': {Orange=20, Banana=30}
HashMap after removing 'Orange': {Banana=30}
size() Method
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// Creating a HashMap object
HashMap<String, String> map = new HashMap<>();
// Adding key-value pairs to the map
map.put("Apple", "Red");
map.put("Orange", "Orange");
map.put("Banana", "Yellow");
map.put("Mango", "Yellow");
System.out.println("Original HashMap: " + map);
// Getting the size of the map
int size = map.size();
System.out.println("Size of the HashMap: " + size);
}
}
Original HashMap: {Mango=Yellow, Orange=Orange, Banana=Yellow, Apple=Red}
Size of the HashMap: 4
containsKey() and containsValue() Methods
boolean containsKey(Object key): Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value): Returns true if this map maps one or more keys to the specified value
Here's an example demonstrating the usage of containsKey() and containsValue() methods in HashMap.
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// Creating a HashMap object
HashMap<String, Integer> studentMarks = new HashMap<>();
// Using put() method to add key-value pairs to the HashMap
studentMarks.put("Alice", 85);
studentMarks.put("Bob", 90);
studentMarks.put("Charlie", 95);
// Displaying the initial HashMap
System.out.println("HashMap: " + studentMarks);
// Checking if the HashMap contains a specific key
System.out.println("Does the HashMap contain key 'Alice'? " + studentMarks.containsKey("Alice"));
System.out.println("Does the HashMap contain key 'Eve'? " + studentMarks.containsKey("Eve"));
// Checking if the HashMap contains a specific value
System.out.println("Does the HashMap contain value 90? " + studentMarks.containsValue(90));
System.out.println("Does the HashMap contain value 100? " + studentMarks.containsValue(100));
}
}
Output:
HashMap: {Bob=90, Alice=85, Charlie=95}
Does the HashMap contain key 'Alice'? true
Does the HashMap contain key 'Eve'? false
Does the HashMap contain value 90? true
Does the HashMap contain value 100? false
We used containsKey() and containsValue() methods to check whether the HashMap contains a specific key or value, respectively. The containsKey() method returns true if the specified key is present in the HashMap, and the containsValue() method returns true if the specified value is present in the HashMap. Otherwise, they return false.
void clear()
The clear() method is used to remove all of the mappings from HashMap.import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// Creating a HashMap object
HashMap<String, Integer> studentMarks = new HashMap<>();
// Using put() method to add key-value pairs to the HashMap
studentMarks.put("Alice", 85);
studentMarks.put("Bob", 90);
studentMarks.put("Charlie", 95);
// Displaying the initial HashMap
System.out.println("Initial HashMap: " + studentMarks);
// Using the clear() method to remove all key-value pairs from the HashMap
studentMarks.clear();
// Displaying the HashMap after calling clear()
System.out.println("HashMap after calling clear(): " + studentMarks);
}
}
Output:
Initial HashMap: {Bob=90, Alice=85, Charlie=95}
HashMap after calling clear(): {}
In this example, we used the clear() method to remove all key-value pairs from the HashMap, effectively emptying it. We display the HashMap again after calling clear(), and as you can see, it's now empty.
isEmpty() Method
The isEmpty() method returns true if this map contains no key-value mappings.
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
System.out.println("Is map empty? " + map.isEmpty());
}
}
Output:
Is map empty? true
values() Method
The values() method returns a Collection view of the values contained in HashMap.
import java.util.*;
public class Main {
public static void main(String[] args) {
// Creating a HashMap object
HashMap<String, Integer> studentMarks = new HashMap<>();
// Using put() method to add key-value pairs to the HashMap
studentMarks.put("Alice", 85);
studentMarks.put("Bob", 90);
studentMarks.put("Charlie", 95);
Collection<Integer> values = studentMarks.values();
System.out.println("Values: " + values);
}
}
Output:
Values: [90, 85, 95]
Conclusion
In this article, we have seen all the important and commonly used HashMap methods with examples. You can learn more about HashMap here: Learn Everything About HashMap
Comments
Post a Comment
Leave Comment