Generic – Java Collections Interview Questions

1. What are the advantages of the Collection Framework in Java?

Below table contains the major advantages of the Java Collection Framework:
Feature Description
The collection framework provides highly effective
Performance and efficient data structures that result in enhancing
the speed and accuracy of a program.
The code developed with the collection framework is
Maintainability easy to maintain as it supports data consistency and
interoperability within the implementation.
The classes in Collection Framework can effortlessly
Reusability mix with other types which results in increasing the
code reusability.
The Collection Framework in Java allows the
Extensibility developers to customize the primitive collection types
as per their requirements.
2. What do you understand by Collection Framework in Java?
The Java Collection framework provides an architecture to store and manage a
group of objects. It permits the developers to access prepackaged data
structures as well as algorithms to manipulate data. The collection framework
includes the following:

 Interfaces

 Classes

 Algorithm
All these classes and interfaces support various operations such as Searching,
Sorting, Insertion, Manipulation, and Deletion which makes the data
manipulation really easy and quick.
3. Describe the Collection hierarchy in Java.
4. List down the primary interfaces provided by Java Collections
Framework?
Below are the major interfaces provided by the Collection Framework:

 Collection Interface: java.util.Collection is the root of the Java Collection

framework and most of the collections in Java are inherited from
this interface.
1public interface Collection<E>extends Iterable
 List Interface: java.util.List is an extended form of an array that contains
ordered elements and may include duplicates. It supports the index-
based search, but elements can be easily inserted irrespective of the
position. The List interface is implemented by various classes such as
ArrayList, LinkedList, Vector, etc.
1public interface List<E> extends Collection<E>
 Set Interface: java.util.Set refers to a collection class that cannot contain
duplicate elements. Since it doesn’t define an order for the elements, the
index-based search is not supported. It is majorly used as a mathematical
set abstraction model. The Set interface is implemented by various classes
such as HashSet, TreeSetand LinkedHashSet.
1public interface Set<E> extends Collection<E>
 Queue Interface: java.util.Queue in Java follows a FIFO approach
i.e. it orders the elements in First In First Out manner. Elements in Queue
will be added from the rear end while removed from the front.
1public interface Queue<E> extends Collection<E>
  Map Interface: java.util.Map is a two-dimensional data structure in Java
that is used to store the data in the form of a Key-Value pair. The key here
is the unique hashcode and value represent the element. Map in Java is
another form of the Java Set but can’t contain duplicate elements.
5. Why Collection doesn’t extend the Cloneable and Serializable
interfaces?
The Collection interface in Java specifies a group of objects called elements. The
maintainability and ordering of elements is completely dependent on the
concrete implementations provided by each of the Collection. Thus, there is no
use of extending the Cloneable and Serializable interfaces.
6. List down the major advantages of the Generic Collection.
Below are the main advantages of using the generic collection in Java:

 Provides stronger type checks at the time of compilation

 Eliminates the need for typecasting

 Enables the implementation of generic algorithms which makes the code

customizable, type-safe and easier to read
7. What is the main benefit of using the Properties file?
The main advantage of using the properties file in Java is that in case the values
in the properties file is changed it will be automatically reflected without having
to recompile the java class. Thus it is mainly used to store information which is
liable to change such as username and passwords. This makes the management
of the application easy and efficient. Below is an example of the same:
1import java.util.*;
2import java.io.*;
3public class PropertiesDemo{
4public static void main(String[] args)throws Exception{
5FileReader fr=new FileReader("db.properties");
6Properties pr=new Properties();
7pr.load(fr);
8System.out.println(pr.getProperty("user"));
9System.out.println(pr.getProperty("password"));
10}
11}
8. What do you understand by Iterator in the Java Collection
Framework?
Iterator in Java is an interface of the Collection framework present in java.util
package. It is a Cursor in Java which is used to iterate a collection of objects.
Below are a few other major functionalities provided by the Iterator interface:
  Traverse a collection object elements one by one

 Known as Universal Java Cursor as it is applicable for all the classes of the
Collection framework

 Supports READ and REMOVE Operations.

 Iterator method names are easy to implement

9. What is the need for overriding equals() method in Java?
The initial implementation of the equals method helps in checking whether two
objects are the same or not. But in case you want to compare the objects based
on the property you will have to override this method.
10. How the Collection objects are sorted in Java?

Sorting in Java Collections is implemented

via Comparable and Comparator interfaces. When Collections.sort() method is
used the elements get sorted based on the natural order that is specified in
the compareTo() method. On the other hand when Collections.sort(Comparator)
method is used it sorts the objects based on compare() method of the
Comparator interface.

List – Java Collections Interview Questions

11. What is the use of the List interface?
The List interface in Java is an ordered collection of elements. It maintains the
insertion order and allows duplicate values to be stored within. This interface
contains various methods which enables smooth manipulation of elements
based on the element index. The main classes implementing the List interface of
the Collection framework are ArrayList, LinkedList, Stack, and Vector.
12. What is ArrayList in Java?
ArrayList is the implementation of List Interface where the elements can be
dynamically added or removed from the list. ArrayList in the Collection
framework provides positional access and insertion of elements. It is an ordered
collection that permits duplicate values. The size of an ArrayList can be increased
dynamically if the number of elements is more than the initial size.
Syntax:
1ArrayList object = new ArrayList ();
13. How would you convert an ArrayList to Array
and an Array to ArrayList?
An Array can be converted into an ArrayList by making use of the asList() method
provided by the Array class. It is a static method that accepts List objects as a
parameter.
Syntax:

Java Certification Training Course

 Instructor-led Sessions

 Real-life Case Studies

 Assignments

 Lifetime Access
Explore Curriculum

1Arrays.asList(item)
Whereas an ArrayList can be converted into an Array using the toArray() method
of the ArrayList class.
Syntax:
1List_object.toArray(new String[List_object.size()])
14. How will you reverse an List?
ArrayList can be reversed using the reverse() method of the Collections class.
Syntax:
1public static void reverse(Collection c)
For Example:
1public class ReversingArrayList {
2public static void main(String[] args) {
3List<String> myList = new ArrayList<String>();
4myList.add("AWS");
5myList.add("Java");
6myList.add("Python");
7myList .add("Blockchain");
8System.out.println("Before Reversing");
9System.out.println(myList.toString());
10Collections.reverse(myList);
11System.out.println("After Reversing");
12System.out.println(myList);
13}
14}
15. What do you understand by LinkedList in Java? How many
types of LinkedList does Java support?
LinkedList in Java is a data structure that contains a sequence of links. Here each
link contains a connection to the next link.
Syntax:
1Linkedlist object = new Linkedlist();
Java LinkedList class uses two types of LinkedList to store the elements:

 Singly Linked List: In a singly LinkedList, each node in this list stores the
data of the node and a pointer or reference to the next node in the list.
  Doubly Linked List: In a doubly LinkedList, it has two references, one to
the next node and another to the previous node.

16. What is a Vector in Java?

Vectors are similar to arrays, where the elements of the vector object can be
accessed via an index into the vector. Vector implements a dynamic array. Also,
the vector is not limited to a specific size, it can shrink or grow automatically
whenever required. It is similar to ArrayList, but with two differences :

 Vector is synchronized.

 Vector contains many legacy methods that are not part of the collections
framework.

Syntax:
1Vector object = new Vector(size,increment);

Queue – Java Collections Interview Questions

17. What are the various methods provided by the Queue
interface?
Below are some of the methods of Java Queue interface:
Method Description
boolean Inserts the specified element into the queue and returns true
add(object) if it is a success.
boolean
Inserts the specified element into this queue.
offer(object)
Object remove() Retrieves and removes the head of the queue.
Retrieves and removes the head of the queue, or returns null
Object poll()
if the queue is empty.
Object element() Retrieves, but does not remove the head of the queue.
Retrieves, but does not remove the head of this queue, or
Object peek()
returns null if the queue is empty.
18. What do you understand by BlockingQueue?
BlockingQueue interface belongs to the java.util.concurrent package. This
interface enhances flow control by activating blocking, in case a thread is trying
to dequeue an empty queue or enqueue an already full queue. While working
with the BlockingQueue interface in Java, you must remember that it does not
accept a null value. In case you try to do that it will instantly throw a
NullPointerException. The below figure represents the working of the
BlockingQueue interface in Java.

Programming & Frameworks Training

FULL STACK WEB DEVELOPMENT INTERNSHIP PROGRAM

Full Stack Web Development Internship Program
Reviews
5(11250)

JAVA CERTIFICATION TRAINING COURSE

Java Certification Training Course
Reviews
4(30150)

PYTHON SCRIPTING CERTIFICATION TRAINING

Python Scripting Certification Training
Reviews
5(5500)

FLUTTER APPLICATION DEVELOPMENT COURSE

Flutter Application Development Course
Reviews
5(4750)

NODE.JS CERTIFICATION TRAINING COURSE

Node.js Certification Training Course
Reviews
5(3850)

SPRING FRAMEWORK CERTIFICATION COURSE

Spring Framework Certification Course
Reviews
5(4650)

ADVANCED JAVA CERTIFICATION TRAINING

Advanced Java Certification Training
Reviews
5(2650)

DATA STRUCTURES AND ALGORITHMS USING JAVA INTERNSHIP

PROGRAM
Data Structures and Algorithms using Java Internship Program
Reviews
5(12050)

PHP & MYSQL WITH MVC FRAMEWORKS CERTIFICATION TRAINING

PHP & MySQL with MVC Frameworks Certification Training
Reviews
5(1900)

Next
19. What is a priority queue in Java?
A priority queue in Java is an abstract data type similar to a regular queue or
stack data structure but has a special feature called priority associated with each
element. In this queue, a high priority element is served before a low priority
element irrespective of their insertion order. The PriorityQueue is based on the
priority heap. The elements of the priority queue are ordered according to the
natural ordering, or by a Comparator provided at queue construction time,
depending on which constructor is used.
20. What is the Stack class in Java and what are the various
methods provided by it?
Java Stack class is an important part of the Java Collection framework and is
based on the basic principle of last-in-first-out. In other words, the elements are
added as well as removed from the rear end. The action of adding an element to
a stack is called push while removing an element is referred to as pop. Below are
the various methods provided by this class:
 Set – Java Collections Interview Questions
21. What is Set in Java Collections framework and list down its
various implementations?
A Set refers to a collection that cannot contain duplicate elements. It is mainly
used to model the mathematical set abstraction. The Java platform provides
three general-purpose Set implementations which are:

1. HashSet

2. TreeSet

3. LinkedHashSet
22. What is the HashSet class in Java and how does it store
elements?
java.util.HashSet class is a member of the Java collections framework which
inherits the AbstractSet class and implements the Set interface. It implicitly
implements a hashtable for creating and storing a collection of unique elements.
Hashtable is an instance of the HashMap class that uses a hashing mechanism
for storing the information within a HashSet. Hashing is the process of
converting the informational content into a unique value that is more popularly
known as hash code. This hashcode is then used for indexing the data
associated with the key. The entire process of transforming the informational
key into the hashcode is performed internally.
23. Can you add a null element into a TreeSet or HashSet?
In HashSet, only one null element can be added but in TreeSet it can’t be added
as it makes use of NavigableMap for storing the elements. This is because the
NavigableMap is a subtype of SortedMap that doesn’t allow null keys. So, in case
you try to add null elements to a TreeSet, it will throw a NullPointerException.
24. Explain the emptySet() method in the Collections framework?
The Collections.emptySet() is used to return the empty immutable Set while
removing the null elements. The set returned by this method is serializable.
Below is the method declaration of emptySet().
Syntax:
1public static final <T> Set<T> emptySet()
25. What is LinkedHashSet in Java Collections Framework?
A java.util.LinkedHashSet is a subclass of the HashSet class and implements the
Set interface. It is an ordered version of HashSet which maintains a doubly-
linked List across all elements contained within. It preserves the insertion order
and contains only unique elements like its parent class.
Syntax:
1LinkedHashSet<String> hs = new LinkedHashSet<String>();
Map – Java Collections Interview Questions
26. What is Map interface in Java?
The java.util.Map interface in Java stores the elements in the form of keys-values
pairs which is designed for faster lookups. Here every key is unique and maps to
a single value. These key-value pairs are known as the map entries. This
interface includes method signatures for insertion, removal, and retrieval of
elements based on a key. With such methods, it’s a perfect tool to use for key-
value association mapping such as dictionaries.
27. Why Map doesn’t extend the Collection Interface?
The Map interface in Java follows a key/value pair structure whereas the
Collection interface is a collection of objects which are stored in a structured
manner with a specified access mechanism. The main reason Map doesn’t
extend the Collection interface is that the add(E e) method of the Collection
interface doesn’t support the key-value pair like Map interface’s put(K, V)
method. It might not extend the Collection interface but still is an integral part of
the Java Collections framework.
28. List down the different Collection views provided by the Map
interface in the Java Collection framework?
The Map interface provides 3 views of key-value pairs which are:

 key set view

  value set view

 entry set view

All these views can be easily navigated through using the iterators.
29. What is the ConcurrentHashMap in Java and do you implement
it?
ConcurrentHashMap is a Java class that implements ConcurrentMap as well as
Serializable interfaces. This class is the enhanced version of HashMap as it
doesn’t perform well in the multithreaded environment. It has a higher
performance rate compared to the HashMap.

Java Certification Training Course

Weekday / Weekend BatchesSee Batch Details

Below is a small example demonstrating the implementation of

ConcurrentHashMap:
1package edureka;
2import java.util.concurrent.*;
3
4public class ConcurrentHashMapDemo {
5 public static void main(String[] args)
6 {
7 ConcurrentHashMap m = new ConcurrentHashMap();
8 m.put(1, "Welcome");
9 m.put(2, "to");
10 m.put(3, "Edureka's");
11 m.put(4, "Demo");
12
13 System.out.println(m);
14
15 // Here we cant add Hello because 101 key
16 // is already present in ConcurrentHashMap object
17 m.putIfAbsent(3, "Online");
18 System.out.println("Checking if key 3 is already present in the Concur
19
20 // We can remove entry because 101 key
21 // is associated with For value
22 m.remove(1, "Welcome");
23 System.out.println("Removing the value of key 1: "+m);
24
25 // Now we can add Hello
26 m.putIfAbsent(1, "Hello");
27 System.out.println("Adding new value to the key 1: "+m);
28
29 // We cant replace Hello with For
30 m.replace(1, "Hello", "Welcome");
31 System.out.println("Replacing value of key 1 with Welcome: "+ m);
32 }
33}
30. Can you use any class as a Map key?
Yes, any class can be used as Map Key as long as the following points are
considered:

 The class overriding the equals() method must also override the
hashCode() method

 The class should adhere to the rules associated with equals() and
hashCode() for all instances

 The class field which is not used in the equals() method should not be
used in hashCode() method as well

 The best way to use a user-defined key class is by making it immutable. It

helps in caching the hashCode() value for better performance. Also if the
class is made immutable it will ensure that the hashCode() and equals()
are not changing in the future.
Differences – Java Collections Interview Questions
31. Differentiate between Collection and Collections.
Collection Collections
java.util.Collection is an interface java.util.Collections is a class
Is used to represent a group of objects It is used to define various utility
as a single entity method for collection objects
It is the root interface of the Collection
It is a utility class
framework
It contains various static methods
It is used to derive the data structures
which help in data structure
of the Collection framework
manipulation
32. Differentiate between an Array and an ArrayList.
Array ArrayList
java.util.Array is a class java.util.ArrayList is a class
It is strongly typed It is loosely types
Cannot be dynamically resized Can be dynamically resized
No need to box and unbox the
Needs to box and unbox the elements
elements
33. Differentiate between Iterable and Iterator.
Iterable Iterator
Iterable is an interface Iterator is an interface
Belongs to java.lang package Belongs to java.util package
Provides one single abstract method Provides two abstract methods called
called iterator() hasNext() and next()
It is a representation of a series of It represents the object with iteration
elements that can be traversed state
34. Differentiate between ArrayList and LinkedList.
ArrayList LinkedList
Implements dynamic array internally to Implements doubly linked list internally
store elements to store elements
Manipulation of elements is slower Manipulation of elements is faster
Can act only as a List Can act as a List and a Queue
Effective for data storage and access Effective for data manipulation
35. Differentiate between Comparable and Comparator.
Comparable Comparator
Present in java.lang package Present in java.util package
Elements are sorted based on natural Elements are sorted based on user-
ordering customized ordering
Provides a single method called Provides to methods equals() and
compareTo() compare()
Modifies the actual class Doesn’t modifies the actual class
36. Differentiate between List and Set.
List Set
An ordered collection of elements An unordered collection of elements
Preserves the insertion order Doesn’t preserves the insertion order
Duplicate values are allowed Duplicate values are not allowed
Any number of null values can be
Only one null values can be stored
stored
ListIterator can be used to traverse the ListIterator cannot be used to traverse
List in any direction a Set
Contains a legacy class called vector Doesn’t contains any legacy class
37. Differentiate between Set and Map.
38. Differentiate between List and Map.
List Map
Belongs to java.util package Belongs to java.util package
Extends the Collection interface Doesn’t extend the Collection interface
Duplicate keys are not allowed but
Duplicate elements are allowed
duplicate values are
Only one null key can be stored but
Multiple null values can be stored
multiple null values are allowed
Preserves the insertion order Doesn’t maintain any insertion order
Stores elements based on Array Data Stores data in key-value pairs using
Structure various hashing techniques
39. Differentiate between Queue and Stack.
Queue Stack
Based on FIFO (First-In-First-Out) Based on LIFO (Last-In-First-Out)
principle principle
Insertion and deletion takes place from Insertion and deletion takes place the
two opposite ends same end
Element insertion is called enqueue Element insertion is called push
Element deletion is called dequeue Element deletion is called pop
Two pointers are maintained one point
Only one pointer is maintained which
to the first element and the other one
points to the top element on the stack
points the last element on the list
40. Differentiate between PriorityQueue and TreeSet.
PriorityQueue TreeSet
It is a type of Queue It is based on a Set data structure
Allows duplicate elements Doesn’t allows duplicate elements
Stores the elements based on an
Stores the elements in a sorted order
additional factor called priority
41. Differentiate between the Singly Linked List and Doubly Linked
List.
Singly Linked List(SLL) Doubly Linked List(DLL)
Contains nodes with a data field and a Contains nodes with a data field, a
next node-link field previous link field, and a next link field
Can be traversed using the next node- Can be traversed using the previous
link field only node-link or the next node-link
Occupies less memory space Occupies more memory space
Less efficient in providing access to the More efficient in providing access to
elements the elements
42. Differentiate between Iterator and Enumeration.
Iterator Enumeration
Collection element can be removed
Can only traverse through the Collection
while traversing it
Used to traverse most of the classes Used to traverse the legacy classes such
of the Java Collection framework as Vector, HashTable, etc
Is fail-fast in nature Is fail-safe in nature
Is safe and secure Is not safe and secure
Provides methods like hasNext(), Provides methods like
next() and remove() hasMoreElements() and nextElement()
43. Differentiate between HashMap and HashTable.
HashMap HashTable
It is non-synchronized in nature It is synchronized in nature
Allows only one null key but multiple
Doesn’t allow any null key or value
null values
Has faster processing has slower processing
Can be traversed by Iterator and
Can be traversed by Iterator
Enumeration
Inherits AbstractMap class Inherits Dictionary class
44. Differentiate between HashSet and HashMap.

45. Differentiate between Iterator and ListIterator.

Iterator ListIterator
Can only perform remove operations Can perform add, remove and replace
on the Collection elements operations the Collection elements
Can traverse List, Sets and maps Can traverse only Lists
Can traverse the Collection in forward Can traverse the collection in any
direction direction
Provides no method to retrieve the Provides methods to retrieve the index
index of the element of the elements
iterator() method is available for the listIterator() is only available for the
 collections implementing the List
entire Collection Framework
interface
46. Differentiate between HashSet and TreeSet.
HashSet TreeSet
Uses HasMap to store elements Uses Treemap to store elements
By default, it stores elements in their
It is unordered in nature
natural ordering
Has faster processing time Has slower processing time
Uses hasCode() and equals() for Uses compare() and compareTo() for
comparing comparing
Allows only one null element Doesn’t allow any null element
Takes up less memory space Takes up more memory space
47. Differentiate between Queue and Deque.
Queue Deque
Refers to single-ended queue Refers to double-ended queue
Elements can be added or removed Elements can be added and removed
from only one end from either end
Less versatile More versatile
48. Differentiate between HashMap and TreeMap.
HashMap TreeMap
Doesn’t preserves any ordering Preserves the natural ordering
Implicitly implements the hashing Implicitly implements the Red-Black
principle Tree Implementation
Can store only one null key Cannot store any null key
More memory usage Less memory usage
Not synchronized Not synchronized
49. Differentiate between ArrayList and Vector.
ArrayList Vector
Non-synchronized in nature Synchronized in nature
It is not a legacy class Is a legacy class
Increases size by double of the
Increases size by 1/2 of the ArrayList
ArrayList
It is not thread-safe It is thread-safe
50. Differentiate between failfast and failsafe.
failfast failsafe
Doesn’t allow modifications of a collection Allows modifications of a
while iterating collection while iterating
Throws ConcurrentModificationException Don’t throw any exceptions
 Uses a copy of the original
Uses the original collection to traverse over
collection to traverse over the
the elements
elements
Don’t require extra memory Require extra memory
So this brings us to the end of the Java Collections interview questions. The
topics that you learned in this Java Collections Interview Questions are the most
sought-after skill sets that recruiters look for in a Java Professional. These sets of
Java Collection Interview Questions will definitely help you ace your job
interview. Good luck with your interview!