Collections in Java

Collections
• 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
 Hierarchy of Collection Framework
The java.util package contains all the classes and interfaces for Collection framework.
 Iterator interface
• Iterator interface provides the facility of iterating the elements in
forward direction only.Methods of Iterator interface
• There are only three methods in the Iterator interface. They are:

– public boolean hasNext() it returns true if iterator has more

elements.
– public object next() it returns the element and moves the cursor
pointer to the next element.
– public void remove() it removes the last elements returned by the
iterator. It is rarely used.
•
 Java ArrayList class
• Java ArrayList class uses a dynamic array for storing the elements.It
extends AbstractList class and implements List interface.
• 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.
•
 Example of Java ArrayList class
import java.util.*;  
class TestCollection1{  
 public static void main(String args[]){  
   
  ArrayList<String> al=new ArrayList<String>();//creating arraylist  
  al.add("Ravi");//adding object in arraylist  
  al.add("Vijay");  
  al.add("Ravi");  
  al.add("Ajay");  
  
  Iterator itr=al.iterator();//getting Iterator from arraylist to traverse elements  
  while(itr.hasNext()){  
   System.out.println(itr.next());  
  }  
 }  
}  
 
Ravi Vijay Ravi Ajay
 Java LinkedList class
• Java LinkedList class uses doubly linked list to store the elements. It
extends the AbstractList class and implements List and Deque
interfaces.
• 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.
 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
 Java List Interface

• List Interface is the subinterface of Collection.It

contains methods to insert and delete elements in
index basis.It is a factory of ListIterator interface.
• Commonly used methods of List Interface:
– public void add(int index,Object element);
– public boolean addAll(int index,Collection c);
– public object get(int Index position);
– public object set(int index,Object element);
– public object remove(int index);
– public ListIterator listIterator();
– public ListIterator listIterator(int i);
 Java ListIterator Interface

• ListIterator Interface is used to traverse the

element in backward and forward direction.
• Commonly used methods of ListIterator
Interface:
– public boolean hasNext();
– public Object next();
– public boolean hasPrevious();
– public Object previous();
 Example of ListIterator Interface:
import java.util.*;  
public class TestCollection8{  
public static void main(String args[]){  
  
ArrayList<String> al=new ArrayList<String>();  
al.add("Amit");  
al.add("Vijay");  
al.add("Kumar");  
al.add(1,"Sachin");  
  
System.out.println("element at 2nd position: "+al.get(2));  
  
ListIterator<String> itr=al.listIterator();  
  
System.out.println("traversing elements in forward direction...");  
while(itr.hasNext()){  
System.out.println(itr.next());  
 }  
  
  
System.out.println("traversing elements in backward direction...");  
while(itr.hasPrevious()){  
System.out.println(itr.previous());  
 }  
}  
}  
Output:
element at 2nd position: Vijay
traversing elements in forward direction...
Amit Sachin Vijay Kumar
traversing elements in backward direction...
Kumar Vijay Sachin Amit
 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.
 Example:
import java.util.*;
public class CollectionsDemo {
public static void main(String[] args) {
Map m1 = new HashMap();
m1.put("Zara", "8");
m1.put("Mahnaz", "31");
m1.put("Ayan", "12");
m1.put("Daisy", "14");
System.out.println();
System.out.println(" Map Elements");
System.out.print("\t" + m1);
}
}
ap Elements {Mahnaz=31, Ayan=12, Daisy=14, Zara=8}
 Comparator interface
• Comparator interface is used to order the objects of user-defined class.

• This interface is found in java.util package and contains 2 methods

compare(Object obj1,Object obj2) and equals(Object element).
• It provides multiple sorting sequence i.e. you can sort the elements based
on any data member. For instance it may be on rollno, name, age or
anything else.
• Syntax of compare method

– public int compare(Object obj1,Object obj2)

 compares the first object with second object.

import java.util.*;  
import java.io.*;  
  
class Simple{  
public static void main(String args[]){  
  
ArrayList al=new ArrayList();  
al.add(new Student(101,"Vijay",23));  
al.add(new Student(106,"Ajay",27));  
al.add(new Student(105,"Jai",21));  
  
System.out.println("Sorting by Name...");  
Collections.sort(al,new NameComparator());  
Iterator itr=al.iterator();  
while(itr.hasNext()){  
Student st=(Student)itr.next();  
System.out.println(st.rollno+" "+st.name+" "+st.age);  
}  
  System.out.println("sorting by age...");  
  
Collections.sort(al,new AgeComparator());  
Iterator itr2=al.iterator();  
while(itr2.hasNext()){  
Student st=(Student)itr2.next();  
System.out.println(st.rollno+" "+st.name+" "+st.age);  
}  
   
}  
}  
Output:
Sorting by Name...
106 Ajay 27
105 Jai 21
101 Vijay 23
Sorting by age...
105 Jai 21
101 Vijay 23
106 Ajay 27