Java Collection Framework

1. Collection Framework
2. Hierarchy of Collection Framework
3. Methods of Collection interface
4. Iterator interface

Collection Framework 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, deletion etc. can be performed by Java Collection Framework.

Collection simply means a single unit of objects. Collection framework provides many interfaces (Set, List, Queue, Deque etc.) and classes (ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet, TreeSet etc).

What is Collection?

Collection represents a single unit of objects i.e. a group.

What is framework?

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

Collection framework

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

1. Interfaces and its implementations i.e. classes
2. Algorithm

Do You Know ?

What are the two ways to iterate the elements of a collection ? What is the difference between ArrayList and LinkedList classes in collection framework ? What is the difference between ArrayList and Vector classes in collection framework ? What is the difference between HashSet and HashMap classes in collection framework ? What is the difference between HashMap and Hashtable class ? What is the difference between Iterator and Enumeration interface in collection framework ? How can we sort the elements of an object. What is the difference between Comparable and Comparator interfaces ? What does the hashcode() method ?

Hierarchy of Collection Framework

Let us see the hierarchy of collection framework.The java.util package contains all the classes and interfaces for Collection framework.

---

Methods of Collection interface

There are many methods declared in the Collection interface. They are as follows:

No.	Method	Description
1	public boolean add(Object element)	is used to insert an element in this collection.
2	public boolean addAll(collection c)	is used to insert the specified collection elements in the invoking collection.
3	public boolean remove(Object element)	is used to delete an element from this collection.
4	public boolean removeAll(Collection c)	is used to delete all the elements of specified collection from the invoking collection.
5	public boolean retainAll(Collection c)	is used to delete all the elements of invoking collection except the specified collection.
6	public int size()	return the total number of elements in the collection.
7	public void clear()	removes the total no of element from the collection.
8	public boolean contains(object element)	is used to search an element.
9	public boolean containsAll(Collection c)	is used to search the specified collection in this collection.
10	public Iterator iterator()	returns an iterator.
11	public Object[] toArray()	converts collection into array.
12	public boolean isEmpty()	checks if collection is empty.
13	public boolean equals(Object element)	matches two collection.
14	public int hashCode()	returns the hashcode number for collection.

---

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.

What we will learn in Collection Framework ?

ArrayList class LinkedList class ListIterator interface HashSet class LinkedHashSet class TreeSet class PriorityQueue class Map interface HashMap class LinkedHashMap class TreeMap class Hashtable class Sorting Comparable interface Comparator interface Properties class in Java

ArrayList class:

uses a dynamic array for storing the elements.It extends AbstractList class and implements List interface. can contain duplicate elements. maintains insertion order. not synchronized. random access because array works at the index basis. manipulation slow because a lot of shifting needs to be occurred.

Hierarchy of ArrayList class:

Example of ArrayList:

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.    
5.   ArrayList al=new ArrayList();  
6.   al.add("Ravi");  
7.   al.add("Vijay");  
8.   al.add("Ravi");  
9.   al.add("Ajay");  
10.   
11.   Iterator itr=al.iterator();  
12.   while(itr.hasNext()){  
13.    System.out.println(itr.next());  
14.   }  
15.  }  
16. }  

Output:Ravi
       Vijay
       Ravi
       Ajay

Two ways to iterate the elements of collection:

1. By Iterator interface.
2. By for-each loop.

Iterating the elements of Collection by for-each loop:

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.    
5.   ArrayList al=new ArrayList();  
6.   al.add("Ravi");  
7.   al.add("Vijay");  
8.   al.add("Ravi");  
9.   al.add("Ajay");  
10.   
11.   for(Object obj:al)  
12.     System.out.println(obj);  
13.  }  
14. }  

Output:Ravi
       Vijay
       Ravi
       Ajay

---

Storing user-defined class objects:

1. class Student{  
2.   int rollno;  
3.   String name;  
4.   int age;  
5.   Student(int rollno,String name,int age){  
6.    this.rollno=rollno;  
7.    this.name=name;  
8.    this.age=age;  
9.   }  
10. }  

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.     
5.   Student s1=new Student(101,"Sonoo",23);  
6.   Student s2=new Student(102,"Ravi",21);  
7.   Student s2=new Student(103,"Hanumat",25);  
8.       
9.   ArrayList al=new ArrayList();  
10.   al.add(s1);  
11.   al.add(s2);  
12.   al.add(s3);  
13.     
14.   Iterator itr=al.iterator();  
15.   while(itr.hasNext()){  
16.     Student st=(Student)itr.next();  
17.     System.out.println(st.rollno+" "+st.name+" "+st.age);  
18.   }  
19.  }  
20. }  

Output:101 Sonoo 23
       102 Ravi 21
       103 Hanumat 25

---

Example of addAll(Collection c) method:

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.    
5.   ArrayList al=new ArrayList();  
6.   al.add("Ravi");  
7.   al.add("Vijay");  
8.   al.add("Ajay");  
9.     
10.   ArrayList al2=new ArrayList();  
11.   al2.add("Sonoo");  
12.   al2.add("Hanumat");  
13.     
14.   al.addAll(al2);    
15.   
16.   Iterator itr=al.iterator();  
17.   while(itr.hasNext()){  
18.    System.out.println(itr.next());  
19.   }  
20.  }  
21. }  

Output:Ravi
       Vijay
       Ajay
       Sonoo
       Hanumat

---

Example of removeAll() method:

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.    
5.   ArrayList al=new ArrayList();  
6.   al.add("Ravi");  
7.   al.add("Vijay");  
8.   al.add("Ajay");  
9.     
10.   ArrayList al2=new ArrayList();  
11.   al2.add("Ravi");  
12.   al2.add("Hanumat");  
13.     
14.   al.removeAll(al2);  
15.   
16.   System.out.println("iterating the elements after removing the elements of al2...");  
17.   Iterator itr=al.iterator();  
18.   while(itr.hasNext()){  
19.    System.out.println(itr.next());  
20.   }  
21.   
22.   }  
23. }  

Output:iterating the elements after removing the elements of al2...
       Vijay
       Ajay
       

---

Example of retainAll() method:

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.    
5.   ArrayList al=new ArrayList();  
6.   al.add("Ravi");  
7.   al.add("Vijay");  
8.   al.add("Ajay");  
9.     
10.   ArrayList al2=new ArrayList();  
11.   al2.add("Ravi");  
12.   al2.add("Hanumat");  
13.     
14.   al.retainAll(al2);  
15.   
16.   System.out.println("iterating the elements after retaining the elements of al2...");  
17.   Iterator itr=al.iterator();  
18.   while(itr.hasNext()){  
19.    System.out.println(itr.next());  
20.   }  
21.  }  
22. }  

Output:iterating the elements after retaining the elements of al2...
       Ravi

LinkedList class:

• uses doubly linked list to store the elements. It extends the AbstractList class and implements List and Deque interfaces.
• can contain duplicate elements.
• maintains insertion order.
• not synchronized.
• No random access.
• manipulation fast because no shifting needs to be occurred.
• can be used as list, stack or queue.

Example of LinkedList:

1. import java.util.*;  
2. class Simple{  
3.  public static void main(String args[]){  
4.    
5.   LinkedList al=new LinkedList();  
6.   al.add("Ravi");  
7.   al.add("Vijay");  
8.   al.add("Ravi");  
9.   al.add("Ajay");  
10.   
11.   Iterator itr=al.iterator();  
12.   while(itr.hasNext()){  
13.    System.out.println(itr.next());  
14.   }  
15.  }  
16. }  

Output:Ravi
       Vijay
       Ravi
       Ajay

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);



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.*;  
class Simple5{  
public static void main(String args[]){  
  
ArrayList al=new ArrayList();  
al.add("Amit");  
al.add("Vijay");  
al.add("Kumar");  
al.add(1,"Sachin");  
  
System.out.println("element at 2nd position: "+al.get(2));  
  
ListIterator 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




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


HashSet class:

uses hashtable to store the elements.It extends AbstractSet class and implements Set interface.
contains unique elements only.


Hierarchy of HashSet class:

Example of HashSet class:







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




Output:Ajay
       Vijay
       Ravi

LinkedHashSet class:

contains unique elements only like HashSet. It extends HashSet class and implements Set interface.
maintains insertion order.


Hierarchy of LinkedHashSet class:

Example of LinkedHashSet class:







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




Output:>Ravi
       Vijay
       Ajay







TreeSet class:

contains unique elements only like HashSet. The TreeSet class implements NavigableSet interface that extends the SortedSet interface.
maintains ascending order.


Hierarchy of TreeSet class:

Example of TreeSet class:







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




Output:Ajay
       Ravi
       Vijay
       







Queue Interface:
The Queue interface basically orders the element in FIFO(First In First Out)manner.

Methods of Queue Interface :

public boolean add(object);
public boolean offer(object);
public remove();
public poll();
public element();
public peek();



PriorityQueue class:
The PriorityQueue class provides the facility of using queue. But it does not orders the elements in FIFO manner.

Example of PriorityQueue:







import java.util.*;  
class Simple8{  
public static void main(String args[]){  
  
PriorityQueue queue=new PriorityQueue();  
queue.add("Amit");  
queue.add("Vijay");  
queue.add("Karan");  
queue.add("Jai");  
queue.add("Rahul");  
  
System.out.println("head:"+queue.element());  
System.out.println("head:"+queue.peek());  
  
System.out.println("iterating the queue elements:");  
Iterator itr=queue.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
}  
  
queue.remove();  
queue.poll();  
  
System.out.println("after removing two elements:");  
Iterator itr2=queue.iterator();  
while(itr2.hasNext()){  
System.out.println(itr2.next());  
}  
  
}  
}  




Output:head:Amit
       head:Amit
       iterating the queue elements:
       Amit
       Jai
       Karan
       Vijay
       Rahul
       after removing two elements:
       Karan
       Rahul
       Vijay




Sorting
We can sort the elements of:

String objects
Wrapper class objects
User-defined class objects


Collections class provides static methods for sorting the elements of collection.If collection elements are of Set type, we can use TreeSet.But We cannot sort the elements of List.Collections class provides methods for sorting the elements of List type elements.


Method of Collections class for sorting List elements

public void sort(List list): is used to sort the elements of List.List elements must be of Comparable type.


Note: String class and Wrapper classes implements the Comparable interface.So if you store the objects of string or wrapper classes, it will be Comparable.

Example of Sorting the elements of List that contains string objects







import java.util.*;  
class Simple12{  
public static void main(String args[]){  
  
ArrayList al=new ArrayList();  
al.add("Viru");  
al.add("Saurav");  
al.add("Mukesh");  
al.add("Tahir");  
  
Collections.sort(al);  
Iterator itr=al.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
 }  
}  
}  




Output:Mukesh
       Saurav
       Tahir
       Viru
       



Example of Sorting the elements of List that contains Wrapper class objects







import java.util.*;  
class Simple12{  
public static void main(String args[]){  
  
ArrayList al=new ArrayList();  
al.add(Integer.valueOf(201));  
al.add(Integer.valueOf(101));  
al.add(230);//internally will be converted into objects as Integer.valueOf(230)  
  
Collections.sort(al);  
  
Iterator itr=al.iterator();  
while(itr.hasNext()){  
System.out.println(itr.next());  
 }  
}  
}  




Output:101
       201
       230

Comparable interface

Comparable interface is used to order the objects of user-defined class.This interface is found in java.lang package and contains only one method named compareTo(Object).It provide only single sorting sequence i.e. you can sort the elements on based on single datamember only.For instance it may be either rollno,name,age or anything else.

Syntax:

public int compareTo(Object obj): is used to compare the current object with the specified object.



We can sort the elements of:

String objects
Wrapper class objects
User-defined class objects


Collections class provides static methods for sorting the elements of collection.If collection elements are of Set type, we can use TreeSet.But We cannot sort the elements of List.Collections class provides methods for sorting the elements of List type elements.


Method of Collections class for sorting List elements

public void sort(List list): is used to sort the elements of List.List elements must be of Comparable type.


Note: String class and Wrapper classes implements the Comparable interface.So if you store the objects of string or wrapper classes, it will be Comparable.


Example of Sorting the elements of List that contains user-defined class objects on age basis

Student.java







class Student implements Comparable{  
int rollno;  
String name;  
int age;  
Student(int rollno,String name,int age){  
this.rollno=rollno;  
this.name=name;  
this.age=age;  
}  
  
public int compareTo(Object obj){  
Student st=(Student)obj;  
if(age==st.age)  
return 0;  
else if(age>st.age)  
return 1;  
else  
return -1;  
}  
  
}  




Simple.java







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));  
  
Collections.sort(al);  
Iterator itr=al.iterator();  
while(itr.hasNext()){  
Student st=(Student)itr.next();  
System.out.println(st.rollno+""+st.name+""+st.age);  
  }  
}  
}  




Output:105 Jai 21
       101 Vijay 23
       106 Ajay 27




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.

Collections class provides static methods for sorting the elements of collection. If collection elements are of Set type, we can use TreeSet. But We cannot sort the elements of List. Collections class provides methods for sorting the elements of List type elements.

Method of Collections class for sorting List elements
public void sort(List list,Comparator c): is used to sort the elements of List by the given comparator.


Example of sorting the elements of List that contains user-defined class objects on the basis of age and name
In this example, we have created 4 java classes:

Student.java
AgeComparator.java
NameComparator.java
Simple.java

Student.javaThis class contains three fields rollno, name and age and a parameterized constructor.







class Student{  
int rollno;  
String name;  
int age;  
Student(int rollno,String name,int age){  
this.rollno=rollno;  
this.name=name;  
this.age=age;  
}  
}  



AgeComparator.javaThis class defines comparison logic based on the age. If age of first object is greater than the second, we are returning positive value, it can be any one such as 1, 2 , 10 etc. If age of first object is less than the second object, we are returning negative value, it can be any negative value and if age of both objects are equal, we are returning 0.







import java.util.*;  
class AgeComparator implements Comparator{  
public int Compare(Object o1,Object o2){  
Student s1=(Student)o1;  
Student s2=(Student)o2;  
  
if(s1.age==s2.age)  
return 0;  
else if(s1.age>s2.age)  
return 1;  
else  
return -1;  
}  
}  



NameComparator.javaThis class provides comparison logic based on the name. In such case, we are using the compareTo() method of String class, which internally provides the comparison logic.







import java.util.*;  
class NameComparator implements Comparator{  
public int Compare(Object o1,Object o2){  
Student s1=(Student)o1;  
Student s2=(Student)o2;  
  
return s1.name.compareTo(s2.name);  
}  
}  



Simple.javaIn this class, we are printing the objects values by sorting on the basis of name and age.







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




Properties class in Java
The properties object contains key and value pair both as a string. It is the subclass of Hashtable.
It can be used to get property value based on the property key. The Properties class provides methods to get data from properties file and store data into properties file. Moreover, it can be used to get properties of system.

Advantage of properties file
Easy Maintenance: If any information is changed from the properties file, you don't need to recompile the java class. It is mainly used to contain variable information i.e. to be changed.

Methods of Properties class
The commonly used methods of Properties class are given below.

Method
Description
public void load(Reader r)
loads data from the Reader object.
public void load(InputStream is)
loads data from the InputStream object
public String getProperty(String key)
returns value based on the key.
public void setProperty(String key,String value)
sets the property in the properties object.
public void store(Writer w, String comment)
writers the properties in the writer object.
public void store(OutputStream os, String comment)
writes the properties in the OutputStream object.
storeToXML(OutputStream os, String comment)
writers the properties in the writer object for generating xml document.
public void storeToXML(Writer w, String comment, String encoding)
writers the properties in the writer object for generating xml document with specified encoding.



Example of Properties class to get information from properties file
To get information from the properties file, create the properties file first.
db.properties







user=system  
password=oracle  



Now, lets create the java class to read the data from the properties file.
Test.java







import java.util.*;  
import java.io.*;  
public class Test {  
public static void main(String[] args)throws Exception{  
    FileReader reader=new FileReader("db.properties");  
      
    Properties p=new Properties();  
    p.load(reader);  
      
    System.out.println(p.getProperty("user"));  
    System.out.println(p.getProperty("password"));  
}  
}  




Output:system
       oracle


Now if you change the value of the properties file, you don't need to compile the java class again. That means no maintenance problem.


Example of Properties class to get all the system properties
By System.getProperties() method we can get all the properties of system. Let's create the class that gets information from the system properties.
Test.java







import java.util.*;  
import java.io.*;  
public class Test {  
public static void main(String[] args)throws Exception{  
  
Properties p=System.getProperties();  
Set set=p.entrySet();  
  
Iterator itr=set.iterator();  
while(itr.hasNext()){  
Map.Entry entry=(Map.Entry)itr.next();  
System.out.println(entry.getKey()+" = "+entry.getValue());  
}  
  
}  
}  




Output:
java.runtime.name = Java(TM) SE Runtime Environment
sun.boot.library.path = C:\Program Files\Java\jdk1.7.0_01\jre\bin
java.vm.version = 21.1-b02
java.vm.vendor = Oracle Corporation
java.vendor.url = http://java.oracle.com/
path.separator = ;
java.vm.name = Java HotSpot(TM) Client VM
file.encoding.pkg = sun.io
user.country = US
user.script = 
sun.java.launcher = SUN_STANDARD
...........




Example of Properties class to create properties file
Now lets write the code to create the properties file.
Test.java







import java.util.*;  
import java.io.*;  
public class Test {  
public static void main(String[] args)throws Exception{  
  
Properties p=new Properties();  
p.setProperty("name","Sonoo Jaiswal");  
p.setProperty("email","sonoojaiswal@javatpoint.com");  
  
p.store(new FileWriter("info.properties"),"Javatpoint Properties Example");  
  
}  
}  



Let's see the generated properties file.
info.properties







#Javatpoint Properties Example  
#Thu Oct 03 22:35:53 IST 2013  
email=sonoojaiswal@javatpoint.com  
name=Sonoo Jaiswal