In this example of Java Generics you will see how to create a generic Map object. Creating a generic Map means that you can define the type of the key and the type of the value of object stored in the Map. The declaration and the instantiation of a generic Map is only different to other type of collection such as List and Set is that we to define two types. One type for the key and the other type for the value.
The syntax for creating a generic Map is as follows:
Map<K, V> map = new Map<K, V>();
Where K is the type of map key and V is the type of the value stored in the map. If you want a map to hold a value of reference to String object and using an Integer as the key, you will write the declaration and instantiation like the snippet below.
Map <Integer, String> map = new HashMap<Integer, String>();
To make it simpler, you can use the diamond operator too.
Map <Integer, String> map = new HashMap<>();
When you want to add some elements to the map you can use the same put() method. But you don’t have to worry that you put a wrong type of object into the map. Because the Java compiler will check it to see if you are storing a correct type. Generic will catch the bug that should not happen at runtime because the code is already validated at compile time.
Map <Integer, String> map = new HashMap<>();
map.put(1, "A");
map.put(2, "B");
map.put(3, "C");
//map.put("4", new Date()); // Compile time error!
String a = map.get(1);
String b = map.get(2);
String c = map.get(3);
The get() method will return a value from the map that correspond with the given key. Because the map know that it store values of string, it will return a string. So you don’t need to cast the return value from the map’s get() method. You might wonder why we can put keys like 1, 2, 3. Doesn’t it supposed to be type of Integer? If you remember the auto boxing feature then you’ll understand this. Behind the screen Java will convert the primitive int to Integer.
Now, after we know how to add elements and read it back from the map. Let iterate the contents of the map. A map will have two collections that you can iterate, the keys and the values. The code snippet below will demonstrate it for you. The first snippet show you how the iterate the map using the key collections while the second iterates the values of the map.
Iterate key collections.
Iterator keyIterator = map.keySet().iterator();
while (keyIterator.hasNext()) {
Integer key = keyIterator.next();
String value = map.get(key);
System.out.println("key = " + key + "; value = " + value);
}
When iterating a map using the key collection you will get the key set of the map and check the hasNext() to see if it has next key. After that you can get the key using the next() method. To get the value you call the get() method and pass the key as the argument.
Iterates value collections.
Iterator valueIterator = map.values().iterator();
while(valueIterator.hasNext()) {
System.out.println("value = " + valueIterator.next());
}
If you want to iterate the value and ignoring the keys you can get the value collections from the map. To validate if it still holds more entries you call the hasNext() method. To obtain the value simply call the next() method from the iterator.
Notice that when using generic you don’t need to do any casting when working with generic map. Everything is added to map and read from the map is according the type of the key and the value of the map. Beside using the Iterator you can also use the for-each loop to iterate the map. Here are the version of the code above written using the for-each loop.
for (Integer key : map.keySet()) {
String value = map.get(key);
System.out.println("key = " + key + "; value = " + value);
}
for (String s : map.values()) {
System.out.println("value = " + s);
}
You can choose either way that match your coding style. Both method of iterating the map object will produce the same result.
