JavaEE |

The different types of map object in java language

In Java, there are several different classes and interfaces available for working with maps. Here are some of the commonly used ones:

  1. java.util.HashMap: It is a widely used implementation of the Map interface. It stores key-value pairs in a hash table, allowing for efficient retrieval and insertion of elements. This implementation does not guarantee the order of the elements.
javaCopy codeMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("Alice", 25);
hashMap.put("Bob", 30);
hashMap.put("Charlie", 35);
  1. java.util.TreeMap: It is another implementation of the Map interface that provides a sorted order of elements based on the natural ordering of the keys or a custom comparator. It is implemented as a red-black tree, which offers efficient operations for searching, insertion, and deletion.
javaCopy codeMap<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Apple", 10);
treeMap.put("Banana", 20);
treeMap.put("Orange", 15);
  1. java.util.LinkedHashMap: This class extends HashMap and maintains the insertion order of elements. It provides predictable iteration order, which is the order in which elements were inserted or accessed.
javaCopy codeMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Apple", 10);
linkedHashMap.put("Banana", 20);
linkedHashMap.put("Orange", 15);
  1. java.util.WeakHashMap: It is an implementation of the Map interface where the keys are weakly referenced. This means that if a key is no longer strongly referenced (i.e., no other references to the key exist), the entry may be garbage collected. It is useful in situations where you want to associate additional information with objects that are already managed by the JVM’s garbage collector.
javaCopy codeMap<String, Integer> weakHashMap = new WeakHashMap<>();
String key = new String("Key");
weakHashMap.put(key, 42);
  1. java.util.EnumMap: This class is specifically designed to work with keys that are instances of an enum. It provides an efficient implementation of a map where the keys are enum constants. It is generally more efficient than other map implementations in this specific use case.
javaCopy codeenum Day {

Map<Day, String> enumMap = new EnumMap<>(Day.class);
enumMap.put(Day.MONDAY, "Monday");
enumMap.put(Day.TUESDAY, "Tuesday");
enumMap.put(Day.WEDNESDAY, "Wednesday");
  1. java.util.IdentityHashMap: It is an implementation of the Map interface that uses reference equality (==) instead of object equality (equals()) when comparing keys. It is useful when you need to use non-standard notions of object equality.
javaCopy codeMap<String, Integer> identityHashMap = new IdentityHashMap<>();
String key1 = "Key";
String key2 = new String("Key");
identityHashMap.put(key1, 42);
identityHashMap.put(key2, 84);

These are some of the commonly used map implementations in Java. Each has its own characteristics and is suitable for different use cases based on factors such as performance, ordering requirements, and key type.


You must be Login in to post a comment.

Related Posts