How HashMap works in Java ?

HashMap :

• HashMap is class from java.util pacakge.
• It stores key value pair in Map.Entry static nested class implementation.
• It maintain only unique key's, one null value is allowed as a key.
• If any key is already present with some value and other key is put with new value then current value of that key get overwrite with new value.
•  HashMap is not synchronized.

Example :

package interviewdev.blogspot.in;

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {

 public static void main(String[] args) {
   
    HashMap hm=new HashMap();  
    
    hm.put(1,"Amit");  
    hm.put(2,"Virat");  
    hm.put(3,"Dhoni");  
    
    for(Map.Entry m:hm.entrySet()){  
     System.out.println(m.getKey()+" "+m.getValue());  
    }  

 }

}

• A HashMap in Java stores key-value pairs. The HashMap requires a hash function and uses hashCode() and equals() functions of Object class, in order to put and retrieve elements to and from the collection respectively.

• When we call put method by passing key-value pair, HashMap uses Key hashCode() with hashing to find out the index to store the key-value pair. The Entry is stored in the LinkedList, so if there are already existing entry, it uses equals() method to check if the passed key already exists, if yes it overwrites the value else it creates a new entry and store this key-value Entry. 
• When we call get method by passing Key, again it uses the hashCode() to find the index in the array and then use equals() method to find the correct Entry and return it’s value. 

• Some important characteristics of a HashMap are its capacity, its load factor and the threshold resizing.
• HashMap initial default capacity is 16 and load factor is 0.75. Threshold is capacity multiplied by load factor and whenever we try to add an entry, if map size is greater than threshold, HashMap rehashes the contents of map into a new array with a larger capacity. The capacity is always power of 2, so if you know that you need to store a large number of key-value pair.
• Below image will explain these detail clearly.

How HashMap works internally ?

HashMap works on the Principal of Hashing. To understand hashing we must understand Hash Function , Hash Value and Bucket. Let's understand each of them.

Hash Function and Hash Value:

• hashCode() function  which returns an integer value is the Hash function. 
• The code for the hashCode() in Object class is as follow :

         public native int hashCode();

• The integer value returned by the above function is known as Hash value.

Bucket : 

• A bucket is used to store key-value pairs.
• In HashMap bucket is Linked List (Simple Linked List for HashMap).

Difference : "Child c = new Child()" and "Parent p = new Child()"

                 Hi Guy's, many time while programming we encounter this kind of declaration's. As it's part of daily development, there are chances of facing this concept in interview. Below simple difference will clear the catch.

Child c = new Child()	Parent p = new Child()
If we know exact run time type of object then we should use this approach.	If we don't know exact run time type of object then we should use this approach (Polymorphism)
By using child reference, we can call both parent and child class methods.	By using parent class reference, we can call only methods available in parent class and child specific methods we can't call.
We can use child reference to hold only that particular child class objects.	We can use parent reference to hold any child class object.
HasMap hmap = new HashMap(); ArrayList alist = new ArrayList();	Map map = new HashMap(); List list = new ArrayList();

Difference : Interface and Abstract class

              This is most common question in the interview room. Many of interviewee are confused or find them-self trapped while answering this question. Following are the basic  difference between the abstract and interface

Interface	Abstract Class
If we don't know anything about implementation, just we have requirement specification then we should go for interface	If we are talking about implementation but not completely (Partial implementation) then we should go for Abstract class
Inside Interface every method is always public and abstract, whether we are declaring or not. Hence interface is also considered as 100% Abstract class	Every method present in Abstract class need not be public and abstract. In addition to abstract methods we can take concrete method also
Every variable present inside interface is always public, static and final whether we are declaring or not	The variable present inside Abstract class need not be public, static and final
We can't declare interface variables with the modifiers : private, protected, transient and volatile	There are no restrictions on Abstract class variable modifiers
For interface variables compulsory we should perform initialization at the time of declaration otherwise we will get compile time error	For Abstract class variables it is not required to perform initialization at the time of declaration
Inside interface we can't declare instance and static block. Otherwise we will get compile time error.	Inide Abstract class we can declare instance and static block
Inside interface we can't declare constructors.	Inside Abstract class we can declare constructor, which will be executed at the time of child objectcreation.
We implements interface.	We extends abstract class