Full Stack Web Development Internship Program
- 29k Enrolled Learners
- Weekend/Weekday
- Live Class
Collection Framework is one of the most important pillars that support the fundamental concepts of the Java programming language. If you are an aspiring Java Developer, it is very important for you to have a strong knowledge of these core concepts before you appear for an interview. Through the medium of this article, I will share the Top 50 Java Collections Interview Questions and Answers that will definitely help you in clearing your interview with flying colors.
The questions in this article have been divided into the following sections:
Below table contains the major advantages of the Java Collection Framework:
Feature | Description |
Performance | The collection framework provides highly effective and efficient data structures that result in enhancing the speed and accuracy of a program. |
Maintainability | The code developed with the collection framework is easy to maintain as it supports data consistency and interoperability within the implementation. |
Reusability | The classes in Collection Framework can effortlessly mix with other types which results in increasing the code reusability. |
Extensibility | The Collection Framework in Java allows the developers to customize the primitive collection types as per their requirements. |
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:
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.
Below are the major interfaces provided by the Collection Framework:
public interface Collection<E>extends Iterable
public interface List<E> extends Collection<E>
public interface Set<E> extends Collection<E>
public interface Queue<E> extends Collection<E>
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.
Below are the main advantages of using the generic collection in Java:
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:
import java.util.*; import java.io.*; public class PropertiesDemo{ public static void main(String[] args)throws Exception{ FileReader fr=new FileReader("db.properties"); Properties pr=new Properties(); pr.load(fr); System.out.println(pr.getProperty("user")); System.out.println(pr.getProperty("password")); } }
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:
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.
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.
🔥𝐄𝐝𝐮𝐫𝐞𝐤𝐚 𝐉𝐚𝐯𝐚 𝐂𝐨𝐮𝐫𝐬𝐞 𝐓𝐫𝐚𝐢𝐧𝐢𝐧𝐠: https://www.edureka.co/java-j2ee-training-course (Use code “𝐘𝐎𝐔𝐓𝐔𝐁𝐄𝟐𝟎”)
This Edureka Java Full Course will help you understand the various fundamentals of Java programm…
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.
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.
ArrayList object = new 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:
Arrays.asList(item)
Whereas an ArrayList can be converted into an Array using the toArray() method of the ArrayList class.
Syntax:
List_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:
public static void reverse(Collection c)
For Example:
public class ReversingArrayList { public static void main(String[] args) { List<String> myList = new ArrayList<String>(); myList.add("AWS"); myList.add("Java"); myList.add("Python"); myList .add("Blockchain"); System.out.println("Before Reversing"); System.out.println(myList.toString()); Collections.reverse(myList); System.out.println("After Reversing"); System.out.println(myList); } }
LinkedList in Java is a data structure that contains a sequence of links. Here each link contains a connection to the next link.
Syntax:
Linkedlist object = new Linkedlist();
Java LinkedList class uses two types of LinkedList to store the elements:
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 object = new Vector(size,increment);
Below are some of the methods of Java Queue interface:
Method | Description |
---|---|
boolean add(object) | Inserts the specified element into the queue and returns true if it is a success. |
boolean offer(object) | Inserts the specified element into this queue. |
Object remove() | Retrieves and removes the head of the queue. |
Object poll() | Retrieves and removes the head of the queue, or returns null if the queue is empty. |
Object element() | Retrieves, but does not remove the head of the queue. |
Object peek() | Retrieves, but does not remove the head of this queue, or returns null if the queue is empty. |
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.
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.
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:
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:
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.
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.
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:
public static final <T> Set<T> emptySet()
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:
LinkedHashSet<String> hs = new LinkedHashSet<String>();
Map – Java Collections Interview Questions
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.
The Map interface provides 3 views of key-value pairs which are:
All these views can be easily navigated through using the iterators.
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.
Below is a small example demonstrating the implementation of ConcurrentHashMap:
package edureka; import java.util.concurrent.*; public class ConcurrentHashMapDemo { public static void main(String[] args) { ConcurrentHashMap m = new ConcurrentHashMap(); m.put(1, "Welcome"); m.put(2, "to"); m.put(3, "Edureka's"); m.put(4, "Demo"); System.out.println(m); // Here we cant add Hello because 101 key // is already present in ConcurrentHashMap object m.putIfAbsent(3, "Online"); System.out.println("Checking if key 3 is already present in the ConcurrentHashMap object: "+ m); // We can remove entry because 101 key // is associated with For value m.remove(1, "Welcome"); System.out.println("Removing the value of key 1: "+m); // Now we can add Hello m.putIfAbsent(1, "Hello"); System.out.println("Adding new value to the key 1: "+m); // We cant replace Hello with For m.replace(1, "Hello", "Welcome"); System.out.println("Replacing value of key 1 with Welcome: "+ m); } }
Yes, any class can be used as Map Key as long as the following points are considered:
Differences – Java Collections Interview Questions
Collection | Collections |
java.util.Collection is an interface | java.util.Collections is a class |
Is used to represent a group of objects as a single entity | It is used to define various utility method for collection objects |
It is the root interface of the Collection framework | It is a utility class |
It is used to derive the data structures of the Collection framework | It contains various static methods which help in data structure manipulation |
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 elements | Needs to box and unbox the elements |
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 called iterator() | Provides two abstract methods called hasNext() and next() |
It is a representation of a series of elements that can be traversed | It represents the object with iteration state |
ArrayList | LinkedList |
Implements dynamic array internally to store elements | Implements doubly linked list internally 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 |
Comparable | Comparator |
Present in java.lang package | Present in java.util package |
Elements are sorted based on natural ordering | Elements are sorted based on user-customized ordering |
Provides a single method called compareTo() | Provides to methods equals() and compare() |
Modifies the actual class | Doesn’t modifies the actual class |
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 stored | Only one null values can be stored |
ListIterator can be used to traverse the List in any direction | ListIterator cannot be used to traverse a Set |
Contains a legacy class called vector | Doesn’t contains any legacy class |
Set | Map |
Belongs to java.util package | Belongs to java.util package |
Extends the Collection interface | Doesn’t extend the Collection interface |
Duplicate values are not allowed | Duplicate keys are not allowed but duplicate values are |
Only one null values can be stored | Only one null key can be stored but multiple null values are allowed |
Doesn’t maintain any insertion order | Doesn’t maintain any insertion order |
List | Map |
Belongs to java.util package | Belongs to java.util package |
Extends the Collection interface | Doesn’t extend the Collection interface |
Duplicate elements are allowed | Duplicate keys are not allowed but duplicate values are |
Multiple null values can be stored | Only one null key can be stored but multiple null values are allowed |
Preserves the insertion order | Doesn’t maintain any insertion order |
Stores elements based on Array Data Structure | Stores data in key-value pairs using various hashing techniques |
Queue | Stack |
Based on FIFO (First-In-First-Out) principle | Based on LIFO (Last-In-First-Out) principle |
Insertion and deletion takes place from two opposite ends | Insertion and deletion takes place the 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 to the first element and the other one points the last element on the list | Only one pointer is maintained which points to the top element on the stack |
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 additional factor called priority | Stores the elements in a sorted order |
Singly Linked List(SLL) | Doubly Linked List(DLL) |
Contains nodes with a data field and a next node-link field | Contains nodes with a data field, a previous link field, and a next link field |
Can be traversed using the next node-link field only | Can be traversed using the previous node-link or the next node-link |
Occupies less memory space | Occupies more memory space |
Less efficient in providing access to the elements | More efficient in providing access to the elements |
Iterator | Enumeration |
Collection element can be removed while traversing it | Can only traverse through the Collection |
Used to traverse most of the classes of the Java Collection framework | Used to traverse the legacy classes such 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(), next() and remove() | Provides methods like hasMoreElements() and nextElement() |
HashMap | HashTable |
It is non-synchronized in nature | It is synchronized in nature |
Allows only one null key but multiple null values | Doesn’t allow any null key or value |
Has faster processing | has slower processing |
Can be traversed by Iterator | Can be traversed by Iterator and Enumeration |
Inherits AbstractMap class | Inherits Dictionary class |
HashSet | HasMap |
Based on Set implementation | Based on Map implementation |
Doesn’t allow any duplicate elements | Doesn’t allow any duplicate keys but duplicate values are allowed |
Allows only a single null value | Allows only one null key but any number of null values |
Has slower processing time | Has faster processing time |
Uses HashMap as an underlying data structure | Uses various hashing techniques for data manipulation |
Iterator | ListIterator |
Can only perform remove operations on the Collection elements | Can perform add, remove and replace operations the Collection elements |
Can traverse List, Sets and maps | Can traverse only Lists |
Can traverse the Collection in forward direction | Can traverse the collection in any direction |
Provides no method to retrieve the index of the element | Provides methods to retrieve the index of the elements |
iterator() method is available for the entire Collection Framework | listIterator() is only available for the collections implementing the List interface |
HashSet | TreeSet |
Uses HasMap to store elements | Uses Treemap to store elements |
It is unordered in nature | By default, it stores elements in their natural ordering |
Has faster processing time | Has slower processing time |
Uses hasCode() and equals() for comparing | Uses compare() and compareTo() for comparing |
Allows only one null element | Doesn’t allow any null element |
Takes up less memory space | Takes up more memory space |
Queue | Deque |
Refers to single-ended queue | Refers to double-ended queue |
Elements can be added or removed from only one end | Elements can be added and removed from either end |
Less versatile | More versatile |
HashMap | TreeMap |
Doesn’t preserves any ordering | Preserves the natural ordering |
Implicitly implements the hashing principle | Implicitly implements the Red-Black Tree Implementation |
Can store only one null key | Cannot store any null key |
More memory usage | Less memory usage |
Not synchronized | Not synchronized |
ArrayList | Vector |
Non-synchronized in nature | Synchronized in nature |
It is not a legacy class | Is a legacy class |
Increases size by 1/2 of the ArrayList | Increases size by double of the ArrayList |
It is not thread-safe | It is thread-safe |
failfast | failsafe |
Doesn’t allow modifications of a collection while iterating | Allows modifications of a collection while iterating |
Throws ConcurrentModificationException | Don’t throw any exceptions |
Uses the original collection to traverse over the elements | Uses a copy of the original collection to traverse over the 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!
Check out the Java Training by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe. We are here to help you with every step on your journey, for becoming a besides this java interview questions, we come up with a curriculum which is designed for students and professionals who want to be a Java Developer. The course is designed to give you a head start into Java programming and train you for both core and advanced Java concepts along with various Java frameworks like Hibernate & Spring.
Got a question for us? Please mention it in the comments section of this “Java Collections Interview Questions” and we will get back to you as soon as possible.
Course Name | Date | Details |
---|---|---|
Java Course Online | Class Starts on 28th September,2024 28th September SAT&SUN (Weekend Batch) | View Details |
edureka.co