Collections in java is a framework that provides an architecture to store and manipulate the group of objects. All the operations that you perform on a data such as searching, sorting, insertion, manipulation, deletion etc can be performed by Java Collections. Java Collection simply means a single unit of objects. Java Collection framework provides many interfaces (Set, List, Queue, Deque etc.) and classes (ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet, TreeSet etc).

What is Collection in java : Collection represents a single unit of objects i.e. a group.

What is framework in java :

• provides readymade architecture.
• represents set of classes and interface.
• is optional.

What is Collection framework

Collection framework represents a unified architecture for storing and manipulating group of objects. It has :

• Interfaces and its implementations i.e. classes
• Algorithm

The collections framework was designed to meet several goals, such as − 1) The framework had to be high-performance. The implementations for the fundamental collections (dynamic arrays, linked lists, trees, and hash tables) were to be highly efficient. 2) The framework had to allow different types of collections to work in a similar manner and with a high degree of interoperability. 3) The framework had to extend and/or adapt a collection easily.

Iterator interface

Iterator interface provides the facility of iterating the elements in forward direction only.

Java – The List Interface

Overview of List collection

Basically, a list collection stores elements by insertion order (either at the end or at a specific position in the list). A list maintains indices of its elements so it allows adding, retrieving, modifying, removing elements by an integer index (zero based index; the first element is at 0-index, the second at 1-index, the third at 2-index, and so on). The following picture illustrates a list that stores some String elements:

A list can store objects of any types. Primitive types are automatically converted to corresponding wrapper types, e.g. integer numbers are converted to Integer objects. It allows null and duplicate elements, and orders them by their insertion order (index).

The List is the base interface for all list types, and the ArrayList and LinkedList classes are two common List’s implementations.

• ArrayList : An implementation that stores elements in a backing array. The array’s size will be automatically expanded if there isn’t enough room when adding new elements into the list. It’s possible to set the default size by specifying an initial capacity when creating a new ArrayList.
• LinkedList : An implementation that stores elements in a doubly-linked list data structure. It offers constant time for adding and removing elements at the end of the list; and linear time for operations at other positions in the list. Therefore, we can consider using a LinkedList if fast adding and removing elements at the end of the list is required.

The following class diagram depicts the inheritance tree of the List collections:

Java ArrayList class

Java ArrayList class uses a dynamic array for storing the elements. It inherits AbstractList class and implements List interface. The important points about Java ArrayList class are:

• Java ArrayList class can contain duplicate elements.
• Java ArrayList class maintains insertion order.
• Java ArrayList class is non synchronized.
• Java ArrayList allows random access because array works at the index basis.
• In Java ArrayList class, manipulation is slow because a lot of shifting needs to be occurred if any element is removed from the array list.

Java Non-generic Vs Generic Collection

Java collection framework was non-generic before JDK 1.5. Since 1.5, it is generic. Java new generic collection allows you to have only one type of object in collection. Now it is type safe so typecasting is not required at run time.

Let’s see the old non-generic example of creating java collection.

ArrayList al=new ArrayList();      //creating old non-generic arraylist

Let’s see the new generic example of creating java collection.

ArrayList<String> al=new ArrayList<String>();       //creating new generic arraylist

In generic collection, we specify the type in angular braces. Now ArrayList is forced to have only specified type of objects in it. If you try to add another type of object, it gives compile time error.

Java ArrayList Example

import java.util.*;  
class TestCollection1{  
public static void main(String args[]){  
ArrayList<String> list=new ArrayList<String>();       //Creating arraylist  
list.add("Ravi");

//Adding object in arraylist  
list.add("Vijay");  
list.add("Ravi");  
list.add("Ajay");  

//Traversing list through Iterator  
Iterator itr=list.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
}  
}  
}

Java LinkedList class

Java LinkedList class uses doubly linked list to store the elements. It provides a linked-list data structure. It inherits the AbstractList class and implements List and Deque interfaces. The important points about Java LinkedList are:

• Java LinkedList class can contain duplicate elements.
• Java LinkedList class maintains insertion order.
• Java LinkedList class is non synchronized.
• In Java LinkedList class, manipulation is fast because no shifting needs to be occurred.
• Java LinkedList class can be used as list, stack or queue.

Hierarchy of LinkedList class

As shown in above diagram, Java LinkedList class extends AbstractSequentialList class and implements List and Deque interfaces.

Doubly Linked List : In case of doubly linked list, we can add or remove elements from both side.

Java LinkedList Example

import java.util.*;  
public class TestCollection7{  
public static void main(String args[]){  
LinkedList<String> al=new LinkedList<String>();  
al.add("Ravi");  
al.add("Vijay");  
al.add("Ravi");  
al.add("Ajay");
Iterator<String> itr=al.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
}  
}  
}

Output:
Ravi
Vijay
Ravi
Ajay

Difference between ArrayList and LinkedList

ArrayList and LinkedList both implements List interface and maintains insertion order. Both are non synchronized classes. But there are many differences between ArrayList and LinkedList classes that are given below :

Java – The Set Interface

A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction. The Set interface contains only methods inherited from Collection and adds the restriction that duplicate elements are prohibited. Set also adds a stronger contract on the behavior of the equals and hashCode operations, allowing Set instances to be compared meaningfully even if their implementation types differ.

The methods declared by Set are summarized in the following table −

Java HashSet class

Java HashSet class is used to create a collection that uses a hash table for storage. It inherits the AbstractSet class and implements Set interface.

The important points about Java HashSet class are: 1) HashSet stores the elements by using a mechanism called hashing. 2) HashSet contains unique elements only.

Difference between List and Set : List can contain duplicate elements whereas Set contains unique elements only.

Java HashSet Example

import java.util.*;  
class TestCollection9{  
public static void main(String args[]){  
//Creating HashSet and adding elements  
HashSet<String> set=new HashSet<String>();  
set.add("Ravi");  
set.add("Vijay");  
set.add("Ravi");
set.add("Ajay");  
//Traversing elements  
Iterator<String> itr=set.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
}  
}  
}

Output:
Ajay
Vijay
Ravi

Java LinkedHashSet class

Java LinkedHashSet class is a Hash table and Linked list implementation of the set interface. It inherits HashSet class and implements Set interface. The important points about Java LinkedHashSet class are: 1) Contains unique elements only like HashSet. 2) Provides all optional set operations, and permits null elements. 3) Maintains insertion order.

Example of LinkedHashSet class:

import java.util.*;  
class TestCollection10{  
public static void main(String args[]){  
LinkedHashSet<String> al=new LinkedHashSet<String>();  
al.add("Ravi");  
al.add("Vijay");  
al.add("Ravi");  
al.add("Ajay");  
Iterator<String> itr=al.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
}  
}  
}

Java TreeSet class

Java TreeSet class implements the Set interface that uses a tree for storage. It inherits AbstractSet class and implements NavigableSet interface. The objects of TreeSet class are stored in ascending order. The important points about Java TreeSet class are: 1) Contains unique elements only like HashSet. 2) Access and retrieval times are quiet fast. 3) Maintains ascending order.

Java TreeSet Example

import java.util.*;  
class TestCollection11{  
public static void main(String args[]){  
//Creating and adding elements  
TreeSet<String> al=new TreeSet<String>();  
al.add("Ravi");  
al.add("Vijay");  
al.add("Ravi");  
al.add("Ajay");  
//Traversing elements  
Iterator<String> itr=al.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
}  
}  
}

Output:
Ajay
Ravi
Vijay

Java – The Map Interface

The Map interface maps unique keys to values. A key is an object that you use to retrieve a value at a later date.

• Given a key and a value, you can store the value in a Map object. After the value is stored, you can retrieve it by using its key.
• Several methods throw a NoSuchElementException when no items exist in the invoking map.
• A ClassCastException is thrown when an object is incompatible with the elements in a map.
• A NullPointerException is thrown if an attempt is made to use a null object and null is not allowed in the map.
• An UnsupportedOperationException is thrown when an attempt is made to change an unmodifiable map.

Java HashMap class

Java HashMap class implements the map interface by using a hashtable. It inherits AbstractMap class and implements Map interface. The important points about Java HashMap class are: 1) A HashMap contains values based on the key. 2) It contains only unique elements. 3) It may have one null key and multiple null values. 4) It maintains no order.

Java HashMap Example

import java.util.*;  
class TestCollection13{  
public static void main(String args[]){  
HashMap<Integer,String> hm=new HashMap<Integer,String>();  
hm.put(100,"Amit");  
hm.put(101,"Vijay");  
hm.put(102,"Rahul");  
for(Map.Entry m:hm.entrySet()){  
System.out.println(m.getKey()+" "+m.getValue());  
}  
}  
}

Output:
102 Rahul
100 Amit
101 Vijay