Collection framework in java interview questions
Read More →
Common collection activities include adding objects, removing objects,
retrieving objects, and iterating.
Three meanings for "collection":
collection : epresents the data structure in which objects are
Collection : java.util interface from which Set and
Collections: A class that holds static collection utility methods.
Few basic operations that are normally used with the
Add objects to the collection.
Remove objects from the collection.
Find out if an object is in the collection.
Retrieve an object from the collection.
Iterate through the collection.
Four basic types of collections include Lists, Sets, Maps, Queues:
Lists : Ordered, duplicates allowed, have an index.
Sets : May or may not be ordered and/or sorted; duplicates not
Maps: keys May or may not be ordered and/or sorted; duplicate keys are
Queues :To process Ordered by FIFO or by priority.
List Interface: A List have index position fore objects.
ArrayList: It is an ordered collection by index but not sorted. It
gives you fast iteration and fast random access.
Vector: A Vector is basically an ArrayList, but Vector
methods are for thread safety. We normally want to use ArrayList
instead of Vector, as the synchronized methods add a performance
LinkedList: A LinkedList is ordered position, like
ArrayList,except the elements are doubly-linked to one another.
A LinkedList may iterate more slowly than an ArrayList, but it's
a good choice when you need fast insertion and deletion. After Java 5
LinkedList class has been enhanced to implement the java.util.Queue
interface. It now supports the common queue methods: peek(), poll(), and
Set Interface: A Set cares about uniqueness.It does not allow
HashSet: It is an unsorted, unordered Set. It uses the hashcode of the
object being inserted.
LinkedHashSet: A LinkedHastSet is an ordered version of
HashSet that maintains a doubly-linked List
across all elements.
Use this class instead of HashSet when we need care about the iteration
TreeSet: The TreeSet is one of the two sorted collections. It
guarantees that all the elements will be in ascending order, according to
Note:- When using HashSet or LinkedHashSet, the objects
we add to them must override hashCode(). If they don’t override hashCode(),
the default Object hashCode() method will allow multiple objects that might
consider "meaningfully equal" to be added to "no duplicates allowed" set.
Map Interface: A Map cares about unique identifiers
HashMap: It is an unsorted, unordered Map.
LinkedHashMap: Like its Set Counterpart, LinkedHashSet, the
LinkedHashMap maintains insertion order
TreeMap: The TreeMap is a Sorted map and it is sorted by natural order.
Queue Interface: This class is new with Java 5.
The purpose of a PriorityQueue is to create a "priority-in,
Queue as opposed to a typical FIFO queue.
Hashtable: Hashtable counterpart of HashMap
ArrayList: Fast iteration and fast random access.
Vector: It's like a slower ArrayList, but it has
LinkedList: Good for adding elements
HashSet: Fast access, assures no duplicates, provides no ordering.
LinkedHashSet: No duplicates; iterates by insertion order.
TreeSet: No duplicates; iterates in sorted order.
HashMap: Fastest updates (key/value pairs); allows one null key,
many null values.
Hashtable: Like a slower HashMap (as with Vector, due to its
synchronized methods). No null values or null keys allowed.
LinkedHashMap: Faster iterations; iterates by insertion order or
last accessed; allows one null key, many null values.
TreeMap: A sorted map.
PriorityQueue: A to-do list ordered by the elements' priority.
Collections hold only Objects, but primitives can be autoboxed
Iterate with the enhanced for, or with an Iterator via hasNext() & next().
hasNext() determines if more elements exist; the Iterator does NOT move.
next() returns the next element and moves the Iterator forward.
To work correctly, a Map's keys must override equals() and hashCode().
Queues use offer() to add an element, poll() to remove the head of the
queue, and peek() to look at the head of a queue.
Sorting can be in natural order, or via a Comparable or many Comparators.
Implement Comparable using compareTo(); provides only one sort order.
Create many Comparators to sort a class many ways; implement compare().
To be sorted and searched, a List's elements must be comparable.
To be searched, an array or List must first be sorted.
A sort() method. Sort using a Comparator or sort using natural order.
A binarySearch() method. Search a pre-sorted array or List.
Arrays.asList() creates a List from an array and links them together.
Collections.reverse() reverses the order of elements in a List.
Collections.reverseOrder() returns a Comparator that sorts in reverse.
Lists and Sets have a toArray() method to create arrays.
What are Generics?
Generics let you enforce compile-time type safety on Collections
Before Java 5 , no syntax for declaring a type Safe Collection.
After Java 5, the above code written as
List myList=new ArrayList
Generics take care of both ends(the putting in and getting out)
List myList=new ArrayList();
myList.add(“Fred”); // OK, it will hold Strings
myList.add(new Circle()); // compiler error
String s = myList.get(0);
pre-generics, when a String wasn't guarantee
String s = (String)myList.get(0);
Used by the Collections.sort() method and the java.utils.Arrays.sort()
method to sort Lists and arrays of objects, respectively.
One sort sequence is allowed.
To implement Comparable, a class must implement a single method,compareTo().