A Collection represents a group of objects known as its elements. The Collection interface is used to pass around collections of objects where maximum generality is desired.
Architecture of collection Framework:


List Interface: A List is a ordered collection that can contain duplicate values.

1.  ArrayList.
2. LinkedList.
3. Vector. 

ArrayList: ArrayList is said to be the best performing List implementation in normal conditions. In expendable array of value or objects.
Example: Copy Element of java ArrayList to Another java ArrayList.import java.util.ArrayList; import java.util.Collections; public class CopyElementsOfArrayListToArrayListExample { public static void main(String[] args) { //create first ArrayList object ArrayList<string> arrayList1 = new ArrayList<string>(); //Add elements to ArrayList arrayList1.add("1"); arrayList1.add("2"); arrayList1.add("3"); //create another ArrayList object ArrayList<string> arrayList2 = new ArrayList<string>(); //Add elements to Arraylist arrayList2.add("One"); arrayList2.add("Two"); arrayList2.add("Three"); arrayList2.add("Four"); arrayList2.add("Five"); /* To copy elements of one Java ArrayList to another use, static void copy(List dstList, List sourceList) method of Collections class. This method copies all elements of source list to destination list. After copy index of the elements in both source and destination lists would be identical. The destination list must be long enough to hold all copied elements. If it is longer than that, the rest of the destination list's elments would remain unaffected. */ System.out.println("Before copy, Second ArrayList Contains : " + arrayList2); //copy all elements of ArrayList to another ArrayList using copy //method of Collections class Collections.copy(arrayList2,arrayList1); /* Please note that, If destination ArrayList object is not long enough to hold all elements of source ArrayList, it throws IndexOutOfBoundsException. */ System.out.println("After copy, Second ArrayList Contains : " + arrayList2); } }
Output:       Before copy, Second ArrayList Contains : [One, Two, Three, Four, Five]
                  After copy, Second ArrayList Contains : [1, 2, 3, Four, Five]
LinkedList: LinkedList is a bit slower than ArrayList but it performs better in certain conditions.
Example: Copy Elements Of LinkedList To another LinkedList.
import java.util.LinkedList; import java.util.Collections; /** * * @author manojkumar */ public class CopyElementsOfLinkedListToLinkedListExample { public static void main(String[] args) { //create first ListedList object LinkedList<string> LinkedList1 = new LinkedList<string>(); //Add elements to ListedList LinkedList1.add("1"); LinkedList1.add("2"); LinkedList1.add("3"); //create another ListedList object LinkedList<string> LinkedList2 = new LinkedList<string>(); //Add elements to Listedlist LinkedList2.add("One"); LinkedList2.add("Two"); LinkedList2.add("Three"); LinkedList2.add("Four"); LinkedList2.add("Five"); /* To copy elements of one Java ListedList to another use, static void copy(List dstList, List sourceList) method of Collections class. This method copies all elements of source list to destination list. After copy index of the elements in both source and destination lists would be identical. The destination list must be long enough to hold all copied elements. If it is longer than that, the rest of the destination list's elments would remain unaffected. */ System.out.println("Before copy, Second ListedList Contains : " + LinkedList2); //copy all elements of ListedList to another ListedList using copy //method of Collections class Collections.copy(LinkedList2,LinkedList1); /* Please note that, If destination LinkedList object is not long enough to hold all elements of source LinkedList, it throws IndexOutOfBoundsException. */ System.out.println("After copy, Second LinkedList Contains : " + LinkedList2); } }
Output:           Before copy, Second LinkedList Contains : [One, Two, Three, Four, Five]
                        After copy, Second LinkedList Contains : [1, 2, 3, Four, Five]
Vector: Vector is also a grow-able  array of objects but unlike ArrayList. vector is thread safe in nature.
Example: Copy Elements Of Vector To another Vector.
import java.util.Collections; import java.util.Vector; public class CopyElementsOfVectorToVectorExample { public static void main(String[] args) { //create first Vector object Vector v1 = new Vector(); //Add elements to Vector v1.add("1"); v1.add("2"); v1.add("3"); //create another Vector object Vector v2 = new Vector(); //Add elements to Vector v2.add("One"); v2.add("Two"); v2.add("Three"); v2.add("Four"); v2.add("Five"); /* To copy elements of one Java Vector to another use, static void copy(List dstList, List sourceList) method of Collections class. This method copies all elements of source list to destination list. After copy index of the elements in both source and destination lists would be identical. The destination list must be long enough to hold all copied elements. If it is longer than that, the rest of the destination list's elments would remain unaffected. */ System.out.println("Before copy, Second Vector Contains : " + v2); //copy all elements of Vector to another Vector using copy //method of Collections class Collections.copy(v2,v1); /* Please note that, If destination Vector object is not long enough to hold all elements of source Vector, it throws IndexOutOfBoundsException. */ System.out.println("After copy, Second Vector Contains : " + v2); } }
Output:             Before copy, Second Vector Contains : [One, Two, Three, Four, Five]
                        After copy, Second Vector Contains : [1, 2, 3, Four, Five]
Queue Interface: A Queue interface  Provides implementation to hold elements prior to their prcessing.
Example: Add Elements Of Queue java.
import java.util.Queue; import java.util.Collections; import java.util.LinkedList; /** * * @author manojkumar */ public class AddElementsOfQueueExample { public static void main(String[] args) { //create first Queue object Queue<string> Queue1 = new LinkedList<string>(); //Add elements to Queue Queue1.add("1"); Queue1.add("2"); Queue1.add("3"); System.out.println("Before Add, One Queue Contains : " + Queue1); Collections.addAll(Queue1, "manoj"); System.out.println("After Add, Second Queue Contains : " + Queue1); } }
Output:            Before Add, one Queue Contains : [1, 2, 3]
                        After Add, Second Queue Contains : [1, 2, 3, manoj]
PriorityQueue: The PriorityQueue class is implemented as a priority heap.
Example: Add Elements Of PriorityQueue java.
import java.util.Collections; import java.util.PriorityQueue; /** * * @author manojkumar */ public class AddElementsOfPriorityQueueExample { public static void main(String[] args) { //create first Queue object PriorityQueue<string> Queue1 = new PriorityQueue<string>(); //Add elements to Queue Queue1.add("1"); Queue1.add("2"); Queue1.add("3"); System.out.println("Before Add, one PriorityQueue Contains : " + Queue1); Collections.addAll(Queue1, "manoj"); System.out.println("After Add, Second PriorityQueue Contains : " + Queue1); } }
Output:        Before Add, One PriorityQueue Contains : [1, 2, 3]
                    After add, Second PriorityQueue Contains : [1, 2, 3, manoj]
Deque Interface: Deque is an interface you need to instantiate a concrete implementation of the interface in order to use it.
Example: Add Elements Of Deque java.
import java.util.Collections; import java.util.Deque; import java.util.LinkedList; /** * * @author manojkumar */ public class AddElementsOfDequeExample { public static void main(String[] args) { //create first Queue object Deque<string> DequeQueue1 = new LinkedList<string>(); //Add elements to DequeQueue DequeQueue1.add("1"); DequeQueue1.add("2"); DequeQueue1.add("3"); System.out.println("Before Add, One DequeQueue Contains : " + DequeQueue1); Collections.addAll(DequeQueue1, "manoj"); System.out.println("After Add, Second DequeQueue Contains : " + DequeQueue1); } }
Output:         Before Add, One DequeQueue Contains : [1, 2, 3]
                     After Add, Second DequeQueue Contains : [1, 2, 3, manoj]
ArrayDeque: ArrayDeque stores its elements internally in an array
Example: Add Elements Of ArrayDeque java.
import java.util.Collections; import java.util.Deque; /** * * @author manojkumar */ public class ArrayDeque { public static void main(String[] args) { //create first Queue object Deque<string> ArrayDeque1 = new java.util.ArrayDeque<string>(); //Add elements to DequeQueue ArrayDeque1.add("1"); ArrayDeque1.add("2"); ArrayDeque1.add("3"); System.out.println("Before Add, One ArrayDeque Contains : " + ArrayDeque1); Collections.addAll(ArrayDeque1, "manoj"); System.out.println("After Add, Second ArrayDeque Contains : " + ArrayDeque1); } }
Output:          Before Add, One ArrayDeque Contains : [1, 2, 3]
                      After Add, Second ArrayDeque Contains : [1, 2, 3, manoj]
Set Interface: A Set is a Interface that does not contain duplicate values in java.

1. Hashset.
2. TreeSet.
3. LinkedHashSet.

HashSet: HashSet is the best performing implementation of set interface. if stored its elements in a HashTable an does not guarantee of any type of ordering in iteration.
Example: Find Minimum element of Java HashSet Example.
import java.util.HashSet; import java.util.Collections; public class FindMinimumOfHashSetExample { public static void main(String[] args) { //create a HashSet object HashSet hashSet = new HashSet(); //Add elements to HashSet hashSet.add(new Long("9237")); hashSet.add(new Long("4298")); hashSet.add(new Long("2374")); hashSet.add(new Long("2473")); hashSet.add(new Long("3298")); /* To find minimum element of Java HashSet use, static Object min(Collection c) method of Collections class. This method returns the minimum element of Java HashSet according to its natural ordering. */ System.out.println("Minimum Element of Java HashSet is : " + hashSet); Object obj = Collections.min(hashSet); System.out.println("Minimum Element of Java HashSet is : " + obj); } }
Output:            Element of Java HashSet is : [3298, 9237, 2374, 2473, 4298]
                          Minimum Element of Java HashSet is : 2374
TreeSet: TreeSet is a Little show than HashSet and it stored its elements in a red-block tree structure. TreeSet orders its elements on the basis of their values.
Example: Add element of Java TreeSet Example.
import java.util.TreeSet; import java.util.Collections; import java.util.Set; public class GetSynchronizedSetFromTreeSetExample { public static void main(String[] args) { //create TreeSet object TreeSet<string> treeSet = new TreeSet<string>(); treeSet.add("m"); treeSet.add("n"); /* Java TreeSet is NOT synchronized. To get synchronized Set from TreeSet use static void synchronizedSet(Set set) method of Collections class. */ Set set = Collections.synchronizedSet(treeSet); System.out.println("TreeSet Output:"+set); Collections.addAll(set, "Java"); System.out.println("Add elements output:"+set); /* Use this set object to prevent any unsynchronized access to original TreeSet object. */ } }
Output:          TreeSet Output:[m, n]
                       Add elements output:[Java, m, n]
LinkedHashSet: LinkedHashSet is implemented as a Hashtable with a LinkedList running through it. it orders its elements on the basis of order in which they were inserted in the set.
Example: Add element of Java LinkedHashSet Example.
import java.util.Collections; import java.util.LinkedHashSet; import java.util.Set; public class LinkedHashSetExample { public static void main(String[] args) { //create LinkedHashSet object LinkedHashSet<string> treeSet = new LinkedHashSet<string>(); treeSet.add("m"); treeSet.add("n"); Set set = Collections.synchronizedSet(treeSet); System.out.println("LinkedHashSet Output:"+set); Collections.addAll(set, "Java"); System.out.println("Add elements output:"+set); } }
Output:                      LinkedHashSet Output:[m, n]
                                  Add elements output:[m, n, Java]