{"id":11979,"date":"2023-01-27T07:39:59","date_gmt":"2023-01-27T07:39:59","guid":{"rendered":"https:\/\/www.prepbytes.com\/blog\/?p=11979"},"modified":"2023-01-27T07:39:59","modified_gmt":"2023-01-27T07:39:59","slug":"hashmap-in-java","status":"publish","type":"post","link":"https:\/\/prepbytes.com\/blog\/hashmap-in-java\/","title":{"rendered":"HashMap in Java"},"content":{"rendered":"

\"\"<\/p>\n

In this article, we will learn about hashmap in java and some important and basic operations on hashmap java and we\u2019ll look at how it works internally.<\/p>\n

Hashmap class in java is defined under java.util package in the Collections framework.HashMap class provides the functionality of HashTable Data Structure. HashMap stores the data in form of Key-Value pair. It is denoted as HashMap where K denotes the Key and V denotes the value.<\/p>\n

Introduction to HashMap Java<\/h2>\n

HashMap class is present in Java Collections Framework and is found in java.util package. It offers the rudimentary Java Map interface implementation. It keeps the information in pairs of (Key, Value), and you can access it using an index of a different kind (e.g. an Integer). A key (index) to another object is created using a first object (value). The element of the relevant key will be replaced if you attempt to insert the duplicate key.<\/p>\n

HashMap is similar to HashTable class but it lacks synchronization.It also allows null keys. To use HashMap we need to import it from the Collections Framework by using the line <\/p>\n

import java.util.HashMap;<\/code><\/pre>\n
Important Points to Know About HashMap in Java<\/h3>\n
Let us first understand some important points about HashMap Java. Some of the feautures of HashMap are:<\/p>\n
    \n
  • It stores Items in key\/value pair.<\/li>\n
  • No Duplicate Keys are allowed.<\/li>\n
  • Data doesn\u2019t maintain its order of insertion.<\/li>\n
  • In HashMap usage of primitive data types is not allowed. We must specify it using Wrapper Classes.<\/li>\n<\/ul>\n
    Hierarchy of HashMap in Collections Framework<\/h2>\n
    \"\"<\/p>\n
    HashMap Java implements Serializable, Cloneable, and Map Interface. It also extends AbstractMap class. <\/p>\n
    Syntax of HashMap Java:<\/h3>\n
    The HashMap is defined as follows in Java:\n\npublic class HashMap extends AbstractMap\n                          implements Map, Cloneable, Serializable<\/code><\/pre>\n
    Parameters of HashMap in Java:<\/h2>\n
    The HashMap in Java has two parameters defined below:<\/p>\n
      \n
    • K: It defines the data type of key used. Moreover, the key must be unique for each item.<\/li>\n
    • V: It defines the data type of values for the keys.<\/li>\n<\/ul>\n
      Creating HashMap in Java<\/h2>\n
      To use HashMap in Java, we need to import it from the java.util package using the line given below:<\/p>\n
      import java.util.HashMap;<\/code><\/pre>\n
      Next we <\/p>\n
      HashMap map = new HashMap();<\/code><\/pre>\n
      An example for this is given below:<\/p>\n
      HashMap map = new HashMap();<\/code><\/pre>\n
      Here in this example, we have the key of String datatype and the values are of Integer datatype.<\/p>\n
      import java.util.HashMap;\n\nclass Main {\n    public static void main(String[] args) {\n\n        \/\/ create a hashmap\n        HashMap countries = new HashMap();\n\n        \/\/ add elements to hashmap\n        countries.put(\"India\", 8);\n        countries.put(\"US\", 1);\n        countries.put(\"Russia\", 3);\n        System.out.println(\"HashMap: \" + countries);\n    }\n}<\/code><\/pre>\n
      Output:<\/strong> <\/p>\n
      HashMap: {India=8, US=1, Russia=3}<\/code><\/pre>\n
      Explanation:<\/strong> In the above example, we have created a HashMap Java named countries and added elements in the map using the put() function.<\/p>\n
      Constructors in HashMap Java<\/h2>\n
      Each of Java’s four hash map constructors has a public access modifier. These are the constructors:<\/p>\n
        \n
      1. HashMap()<\/li>\n
      2. HashMap(int initialCapacity)<\/li>\n
      3. HashMap(int initialCapacity, float loadFactor)<\/li>\n
      4. HashMap(Map map)<\/li>\n<\/ol>\n
        Lets delve further into a few other terminologies to gain a better grasp before going into the constructors in detail:<\/p>\n
        Hashing:<\/strong> Javas HashMap implements the hashing algorithm, which converts object data into a set of representative integer values. Using the method hashCode, one can turn an object into integer form through the process of hashing (). The object class’s hashCode() method returns an integer representation of the object’s memory reference. To store and retrieve any key-value pair, the hash function is therefore used to the key object to determine the bucket’s index.<\/p>\n
        Capacity:<\/strong> Capacity is defined as the number of buckets stored in the HashMap. The initial Default Capacity of HashMap Java is 16.<\/p>\n
        Load Factor:<\/strong> The Load Factor is the measure that decides when to increase the capacity of hashmap java. The default value is 75%.<\/p>\n
        Threshold:<\/strong> The approximate product of the current capacity and load factor is the threshold of a Java hash map.<\/p>\n
        Rehashing:<\/strong> Recalculating the hash code for already-stored information is known as "rehashing." The Map is rehashed to have almost twice as many buckets as before when the number of entries in the hash table exceeds the threshold value.<\/p>\n
        Collision:<\/strong> When a hash function returns the same bucket position for two separate keys, it is referred to as a collision.<\/p>\n
        Constructor 1: HashMap()<\/h3>\n
        It is the default function constructor that builds a HashMap object with a load factor of 0.75 and an initial capacity of 16.<\/p>\n
        Syntax:<\/strong><\/p>\n
        HashMap map = new HashMap();<\/code><\/pre>\n\t\t\t\t\t\t