Explore topic-wise InterviewSolutions in .

WeakHashMap is using the WeakReference class, first, we need to understand how WeakReference works, WeakReference is a class which HOLDS the reference and GC captured that reference eagerly and does the garbage collection.

Below is the code snippet for WeakReference.

In this case, prime no gets garbage collected easily.

The WeakHashMap has utilized the WeakReference CLASSES, below code structure of WeakHashMap shows about the utilizing of WeakReference. The WeakHashMap extends the WeakReference classes

Key is stored as a WeakReference in ReferenceQueue, whenever the JVM get the key its add in the ReferenceQueue, so as soon as WeakHashMap check any key and if it found is deletes it from the table, this operation is called every time before any get operation.

Predominantly the WeakHashMap is given better memory performance, one can use this whenever we have to implement the custom cache or need to add a volume of the record in the Map.

The concurrentHashMap works on the principle of segmentation, which divides the  HashMap into segments and each SEGMENT allocated to each THREAD and LOCKED for same so other thread will not interfere with each other, the default size of segments in each ConcurrentHashMap is 32.

Below is the internal code structure of ConcurrentHashMap.

This below code works as an internal class of ConcurrentHashMap.

CopyOnWriteArrayList CREATES a clone of the actual list, for EVERY successive update operation will update internally to the actual list without generating the concurrent modification EXCEPTION, and prevent to throw the concurrent modification exception. HOWEVER, to use this cost more on memory consumption because for every update operation there is one clone copy gets created, we have to use wisely when there is frequent read operation, it is better to use when the same list is shared by a number of thread, whereas ArrayList doesn’t allow any thread safety.

However whenever any modification takes place while traversing in the ARRAY lIst its throws the concurrent modification exception.

Stack and Queue work on the principal of First in Last Out and First in First out.

The best use case of Queue is in the MESSAGING SERVICES, where we implement the messaging container, which allows one message to get input and another message get output from the queue.

The queue has the ability to also act as a buffer to store the elements for the temporary time.

Whereas Stack best use is to perform prefix, POSTFIX and infix operation in the Tree.

Below is the code example of Stack:

Below is the code example of Queue:

Iterator and Enumerator are two different classes in the collection api, which is used to perform the traversing to a collection object. The use case is whenever there is a NEED to traverse the elements and there is no need to add and update the elements in the list than its good to go with the Enumerator, an enumerator is basically a legacy class which is a SUPPORT to all the legacy classes Vector, Stack, HashTable.

Whereas Iterator is an advanced way to handle the traversing when there is a requirement to modify the elements in the collection object than we can use the Iterator. Iterator can support all kinds of Collection class like List, Map and Set.

Iterator can provide fail-safe and fall fast according to the corresponding collection class.

Below is the code snippet for Enumeration

import java.util.*;

Comparable is part of java.lang package, which is used to compare another object from itself, the way it works that the class needs to implement the comparable interface and need to override the compare method which takes another object as a parameter, this scenario is when we use it to implement natural comparison with another object, it could be any user-defined class.The return type of compareTo() method is int type which could return three different values (-1, 0, 1) Below is the code snippet for same.

The comparator is an interface of java.util package which predominantly works on collection library, the best use case is to compare the two different collection object. The sorting can perform using Collections utility class.

Below is the code representation.

Collections are the utility class which has the sort method takes an input of list of the employee and implemented comparator class use to perform the sorting.

Fail fast and fail-safe is one of the prominent features of collection iterator framework, which works on the principle of modification of a record in the collection object while iterating over it, HOWEVER, both have a different way to handle.

Fail Fast iterator: The fail-fast iterator checks, If there is modification happening while iterating over the elements, it will check and throw the exception called a ConcurrentModificationException. Typically the fail-fast iterator implements the volatile counter whenever the iterator gets instantiated this counter embedded to the iterator and in the case of any modification it will increment the counter if it is greater than one it will throw the exception. Below is the code snippet for same.

Fail-safe Iterator: Fail safe iterator is a part of the java.util.concurrent api, it works on the principal of the CLONING, actually in this case it creates the clone of the object and iterate over it, if any modification happens, it wouldn’t touch to the actual object and continue to iterate without failure. One issue with the fail-safe iterator is, it doesn’t guarantee that updated elements will be reflected in the iteration.  And another issue is it CONSUMES more memory than fail fast because it requires to create the clone, whereas failing fast works only original one.

The CopyOnWriteArrayList and ConcurrentHashMap is the example of fail-safe iterator.

Below is the code snippet for same.

Initial capacity in HashMap plays a vital ROLE in the allocation of memory as we know that HashMap works on the key-value pair, that means the HashMap needed a large AMOUNT of memory to maintain the key and value, to overcome these challenges the HashMap works on the principal to allocate the optimum size, whenever the HashMap get instantiated, that is CALLED Initial capacity, which is usually a 16.

Now let’s focus on load factor, so there is a concept of threshold value, which is always a 0.75 size of the total capacity, the significance of this is whenever any new record gets inserted in the HashMap, the HashMap COMPUTES the allocated size of the HashMap, then it checks whether this size reaches the threshold value then HashMap increased the size of 75% from the CURRENT size to augmented the storage for next incoming record.

The time complexity of HASHMAP to getting the elements is usually from O(N) to O(Log(n)), when there is no collision OCCURS and the worst case is O(n) to O(1), because when collision occurs and HashMap needs to travel till the end of the linked list. Now in the case of putting the elements in HashMap, is always O(1). Below classes is the implementation of Map interface.

• LinkedHashMap,
• HashMap
• Hashtable,
• WeakHashMap,
• IdentityHashMap,
• ConcurrentHashMap,
• TreeMap, and
• EnumMap.

However, as PER the MEMORY performance basis, the WeakHashMap gives better performance. But it doesn’t provide the thread safety if one needs to achieve the thread safety, to achieve the thread safety one needs to use the ConcurrentHashMap because it provides thread safety without using synchronization.

The COLLISION problem is, whenever the hash function returns the same INDEX position for the different key, then a collision occurs. The collision detection technique is also called collision detection.

Now, let's move to the collision prevention technique. The HashMap uses below algorithms to resolve the collision problem.

1. Linear probing: This algorithm is default implementation to resolve the collision issue, lets see how it works, in this approach HashMap implements LinkedList data structure to store the elements, while collision occurs HashMap first check the index position using the hashcode of key, if it founds same index position and conflict with other keys, then HashMap calls the equals() method of the Key, so using the composite approach of hashcode() and equals() method, the HashMap start traversing on linear(one by one) elements in LinkedList, because HashMap also maintain the equal() method of information in the linked LIST to store the elements, using both this approach the HashMap finds the correct elements in the linked list.
2. Below is the CODE snippet forget operation in the HashMap. Where get method takes the Key object as input and returns the Value object as V and checking WHETHER the Key is null, then calculate the hash code and iterate over the hash map.

Hashmap compose with an array of node and Node is an object of a class which has following below object:

• HashKey of int type
• Key of type K
• Value of type V
• Reference of next Node

Let’s see how it all together works, first will approach to hashing process, which uses a hashing algorithm to generate index position-taking as an input of hashkey value of the corresponding object. Let’s look on below code snippet:

The moment, when we passing the key object in the put method of hashmap like below

The HashMap calling the hashcode() method of object and get the 10 digit numeric value, which eventually passing to the hashing algorithms which is like below syntax

f(h(hashCode (key) % array_length)) = {index position} of hashmap, ,where x is a hashcode value, according to the index position the hashmap insert the value object in the corresponding bucket. HashMap uses the linkedlist to store the value object.

Below is the implementation of HashMap, where K is the Key and V is the Value, usually the initial capacity is always 16, whenever the map get instantiated and it's computed every time when its reach to a threshold value which is 0.75,

The retrieval process of HashMap is, it has to compute the hashcode whenever the get method call which along with the key, using the key, hashmap computes the index position and equal() plays the vital role to identify the correct object from the bucket or LinkedList. Below is the code snippet for same.

There is a collision issue happening which is usually taken care of by collision detection and collision prevention.

• Comparable: 

A comparable object is capable of comparing itself with another object. The class itself must implement the java.lang.Comparable interface to COMPARE its instances.

Comparable has compareTo(Object o) to sort the objects

Consider a Product class that has members like, productId, productName, ManufacturerYear. Suppose we wish to sort a LIST of Products based on year of productId. We can implement the Comparable interface with the Product class, and we override the method compareTo() of Comparable interface.

• Comparator: 

A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class’s instances. This comparator class must implement the java.util.Comparator interface.

Comparator has compare(Object o1, Object o2) to sort the objects.

We can ITERATE a List in two ways:

• for-each LOOP
• Using Iterator

Here is the code SNIPPET:

We can traverse the elements in a LIST using Iterator in a forward direction. Using LISTITERATOR, we can traverse the elements in the forward and backward direction both. Iterator can be USED in these collection types: List, Set, and Queue.

ListIterator can be used in List collection only.

Iterator has the following FUNCTIONALITIES:

• boolean hasNext()
• E next()
• void remove()

ListIterator has the following functionalities:

• void add (E e)
• boolean hasNext()
• boolean hasPrevious()
• void remove()

Iterator can only perform remove operation while traversing the elements in a collection. If we TRY to add elements, it will throw ConcurrentModificationException.

ListIterator can perform add, remove operation while traversing the elements in a collection. We won’t get any exception while adding element using ListIterator.

• Interface java.lang.Iterable Iterable is the root interface of the COLLECTIONS API
  • Interface Collection
• Interface List

List is a collection of unordered elements. It contains duplicate elements also.

• Interface Set

Set is a collection of ORDERED elements. It doesn’t contain any duplicate elements.

• Interface Queue

Queue interface available in java.util package and EXTENDS Collection interface

• Interface Map
  • Interface SortedMap

Map is a collection of (key,value) PAIR.

• Convert Map Keys To List

• Convert Map VALUES To List

You can see the below code snippet:

• Arrays of STRING to List

Arrays class of java.util package contains asList() which helps to convert an array of strings to List. This method bridges between array-based and collection-based APIS. The returned List is serializable and implements RandomAccess

• Below is the code snippet :

• List of String to Array of String

Stack is a data structure which follows the principle of LIFO (Last In Fast Out) OR FILO (First In Last Out), i.e element inserted at last will be the first to be removed from the stack.

Queue is a data structure which follows the principle of FIFO (First In First Out), i.e. element inserted at first to the list will be the first to be removed from the list.

For Stack, insertion and deletion of an element are TERMED as PUSH and POP while for Queue, insertion, and deletion of an element are termed as  ENQUEUE and DEQUEUE.

In JAVA, Stack is a class present in java.util package and Queue is an interface present in java.util package.

Iterator is an interface. It is PRESENT in java.util package. It has the following functionalities:

• hasNext() : Boolean
• next() : E
• Code snippet to SHOW how to use Iterator:

In your program, if you try to insert the elements and retrieve the elements in the same order, then you should use LinkedList. Complexity for inserting an element is O(n) in case of LinkedList.

If you don't NEED to MAINTAIN the insertion or deletion order, then you can use ArrayList. Also, the complexity of insertion and deletion in an ArrayList is O(1) as this data structure is indexed. An element can directly be accessed in ArrayList using index.

Code Snippet:

Insertion in an ArrayList can be DONE in 2 ways:

 Insertion/ deletion in LinkedList:

LIST is an ordered collection of elements and hence it maintains insertion order of elements while Set doesn't maintain any ORDERING of the elements. List allows DUPLICATE elements while Set doesn't allow any elements. List is index-based, i.e.we can access elements in List based on Index, whereas we can’t access Set using index. Concrete implementation of List INTERFACE are ArrayList, LinkedList, etc. Concrete implementation of Set implementations are HashSet, LinkedHashSet, TreeSet etc. we can insert any NUMBER of null values in List. But we can have only a single null value at most in Set. ListIterator can be used to traverse a List in both directions (forward and backward) however it cannot be used to traverse a Set. Using Iterator, we can traverse the elements in Set and List.

1. HASHMAP:

• HashMap is an implementation of map interface, where it's utilizing the hashing algorithms to calculate the index position using hashcode() VALUES from the keys.
• HashMap guaranteed the time complexity of O(1) for insertion and searching.
• Code Snippet: Map map = new HashMap();  
• Use case: Sometimes when the DATA is huge and at the same time, we need faster insertion and retrieval because the time complexity is O(1) and regardless considering the order of the data, I would say that in this case, one can use the HashMap.

2. LinkedHashMap

Linked HashMap is an implementation of the map interface along with the hashing algorithms it also supports the ordering according to the insertion order.

Code Snippet: Map map = new LinkedHashMap();

Use Case: LinkedHashMap is useful whenever we need to maintain the ordering of keys to match the ordering of insertion. along with that when we need to handle the caching mechanism.

3. TreeMap

TreeMap is an implementation of the map interface, where it follows the Tree data structure which is RedBlack Tree implementation and follows the natural order  

Code Snippet: Map map = new TreeMap();

Use case: One can use the TreeMap when we need the natural ordering, or we need to sort the record alphabetically or ascending and descending order.

A map is an object that maps keys to VALUES. The map works on key-value pair principal. A map doesn't allow to contain duplicate keys. Each key can map to at most one value. HashMap, TreeMap, ConcurentHashMap are the implementation of the map. The map has three kind of collection like key, values and key values and it doesn’t IMPLEMENT the collection interface that is the reason the Map interface doesn’t fall in the collection HIERARCHY. The order of the map depends on the specific implementation classes.

Code Snippet:  Map map = new HashMap();.

The best use case is when we need to SPECIFY the pairing between the object and store accordingly.

• Dequeue:
  • The Deque INTERFACE provides the facility of using double ended queue means we can use either end to PUSH and pop the elements.
  • ArrayDeque is one of the implementations.
  • Unlike Queue, we can add or remove elements from both sides.
  • Null elements are not allowed in the ArrayDeque.
  • ArrayDeque is faster than LinkedList and Stack.
  • CodeSnippet: Deque<String> deque=new ArrayDeque<String>();  
• SortedSet
  • This interface extends Set and provides a total ORDERING of its elements.
  • The implementation class of the SortedSet interface has an implementation of the Comparable interface so that all the elements in the set can mutually comparable.
  • SortedSet by default do the sorting on ascending order.
  • TreeSet is an implementation of a sorted set interface.
  • Code Snippet: SortedSetsortedSet = new SortedSet();
• NavigableSet:
  • NavigableSet is responsible for a navigable set in Java Collection Framework.
  • The NavigableSet interface inherits from the SortedSet interface.
  • It behaves like a SortedSet with the exception that we have navigation methods available in addition to the sorting mechanisms of the SortedSet.
  • For example, NavigableSet interface can NAVIGATE the set in reverse order compared to the order defined in SortedSet.
  • The classes that implement this interface are, TreeSet and ConcurrentSkipListSet
  • Code snippet: NavigableSet set = new

1. Set

• Set is a collection, which avoids containing duplicate ELEMENTS.
• This interface models the mathematical set abstraction and is used to represent sets, such as the deck of cards.
• Set doesn’t maintain the order.
• HashSet, LinkedHashSet or TreeSet are the implementations of the Set interface.
• Set also adds a stronger contract on the behaviour of the equals and hashCode
• Code SNIPPET: Set set = new HashSet();

2. List

• The list follows the ordered collection and can contain duplicate elements.
• One can access any element from its index.
• The list is somewhat like array however length is changing at runtime.
• List interface doesn’t provide the thread safety.
• ArrayList, LinkedList, CopyOnWriteArray are the implementation of List interface.
• Code Snippet: List list = new ArrayList();

3. Queue

• Queue interface is a part of collection framework extend the collection interface.
• A queue is used to insert elements at the end of the queue and removes from the beginning of the queue. It BASED on the FIFO concept.
• The queue is inherited from the Collection framework, so it supports all the method like insertion and deletion.
• ArrayBlockingqueue and PriorityQueue are the most widely used implementation classes.
• public class PriorityQueue<E&GT; extends AbstractQueue<E> implements Serializable  
• Code Snippet: Queue queue = new PriorityQueue();

Collection framework provides all the implementation of available data STRUCTURE, which reduces the development time. All the classes are growable classes, that means we don’t need to PROVIDE the size at compile time. Later release Collection framework also starts supporting the Generics. Collection framework also starts supporting the thread collection class like ConcurrentHashMap and CopyOnWriteArrayList. Code quality also getting improved by USING well-tested collection API. Reduce code maintenance by using the collection framework. Collection API also provides the UTILITY class called Collections. Enhance the REUSABILITY and interpretability the code base.

The collection is an API, INTRODUCED in JDK 5. Initially, the collection got released with some of few classes with Vector, Stack, Hash table, ARRAY. The collection is an API which has got various implementation of data structure LIST, Set, Stack, Queue, Map. The available implementation classes can group the N no of objects without specifying the SIZE. Collection API provides the growable object. All these classes are a growable class which increases the size at runtime.