Unit - 5

Collection Framework

5.1 Collection Framework: Introduction

The Collection in Java is a framework that provides an architecture to store and manipulate the group of objects.

Java Collections can achieve all the operations that you perform on a data such as searching, sorting, insertion, manipulation, and deletion.

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

What is Collection in Java

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

What is a framework in Java

• It provides readymade architecture.
• It represents a set of classes and interfaces.
• It is optional.

What is Collection framework

The Collection framework represents a unified architecture for storing and manipulating a group of objects. 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?
• What is the difference between Java collection and Java collections?

Hierarchy of Collection Framework

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

Methods of Collection interface

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

Iterator interface

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

Methods of Iterator interface

There are only three methods in the Iterator interface. They are:

Iterable Interface

The Iterable interface is the root interface for all the collection classes. The Collection interface extends the Iterable interface and therefore all the subclasses of Collection interface also implement the Iterable interface.

It contains only one abstract method. i.e.,

Iterator<T> iterator()  

It returns the iterator over the elements of type T.

Collection Interface

The Collection interface is the interface which is implemented by all the classes in the collection framework. It declares the methods that every collection will have. In other words, we can say that the Collection interface builds the foundation on which the collection framework depends.

Some of the methods of Collection interface are Boolean add ( Object obj), Boolean addAll ( Collection c), void clear(), etc. which are implemented by all the subclasses of Collection interface.

List Interface

List interface is the child interface of Collection interface. It inhibits a list type data structure in which we can store the ordered collection of objects. It can have duplicate values.

List interface is implemented by the classes ArrayList, LinkedList, Vector, and Stack.

To instantiate the List interface, we must use :

1. List <data-type> list1= new ArrayList();  
2. List <data-type> list2 = new LinkedList();  
3. List <data-type> list3 = new Vector();  
4. List <data-type> list4 = new Stack();  

There are various methods in List interface that can be used to insert, delete, and access the elements from the list.

The classes that implement the List interface are given below.

ArrayList

The ArrayList class implements the List interface. It uses a dynamic array to store the duplicate element of different data types. The ArrayList class maintains the insertion order and is non-synchronized. The elements stored in the ArrayList class can be randomly accessed. Consider the following example.

1. Import java.util.*;  
2. Class TestJavaCollection1{  
3. Public static void main(String args[]){  
4. ArrayList<String> list=new ArrayList<String>();//Creating arraylist  
5. List.add("Ravi");//Adding object in arraylist  
6. List.add("Vijay");  
7. List.add("Ravi");  
8. List.add("Ajay");  
9. //Traversing list through Iterator  
10. Iterator itr=list.iterator();  
11. While(itr.hasNext()){  
12. System.out.println(itr.next());  
13. }  
14. }  
15. }  

Output:

Ravi

Vijay

Ravi

Ajay

LinkedList

LinkedList implements the Collection interface. It uses a doubly linked list internally to store the elements. It can store the duplicate elements. It maintains the insertion order and is not synchronized. In LinkedList, the manipulation is fast because no shifting is required.

Consider the following example.

1. Import java.util.*;  
2. Public class TestJavaCollection2{  
3. Public static void main(String args[]){  
4. LinkedList<String> al=new LinkedList<String>();  
5. Al.add("Ravi");  
6. Al.add("Vijay");  
7. Al.add("Ravi");  
8. Al.add("Ajay");  
9. Iterator<String> itr=al.iterator();  
10. While(itr.hasNext()){  
11. System.out.println(itr.next());  
12. }  
13. }  
14. }  

Output:

Ravi

Vijay

Ravi

Ajay

Vector

Vector uses a dynamic array to store the data elements. It is similar to ArrayList. However, It is synchronized and contains many methods that are not the part of Collection framework.

Consider the following example.

1. Import java.util.*;  
2. Public class TestJavaCollection3{  
3. Public static void main(String args[]){  
4. Vector<String> v=new Vector<String>();  
5. v.add("Ayush");  
6. v.add("Amit");  
7. v.add("Ashish");  
8. v.add("Garima");  
9. Iterator<String> itr=v.iterator();  
10. While(itr.hasNext()){  
11. System.out.println(itr.next());  
12. }  
13. }  
14. }  

Output:

Ayush

Amit

Ashish

Garima

Stack

The stack is the subclass of Vector. It implements the last-in-first-out data structure, i.e., Stack. The stack contains all of the methods of Vector class and also provides its methods like boolean push(), boolean peek(), boolean push(object o), which defines its properties.

Consider the following example.

1. Import java.util.*;  
2. Public class TestJavaCollection4{  
3. Public static void main(String args[]){  
4. Stack<String> stack = new Stack<String>();  
5. Stack.push("Ayush");  
6. Stack.push("Garvit");  
7. Stack.push("Amit");  
8. Stack.push("Ashish");  
9. Stack.push("Garima");  
10. Stack.pop();  
11. Iterator<String> itr=stack.iterator();  
12. While(itr.hasNext()){  
13. System.out.println(itr.next());  
14. }  
15. }  
16. }  

Output:

Ayush

Garvit

Amit

Ashish

Queue Interface

Queue interface maintains the first-in-first-out order. It can be defined as an ordered list that is used to hold the elements which are about to be processed. There are various classes like PriorityQueue, Deque, and ArrayDeque which implements the Queue interface.

Queue interface can be instantiated as:

1. Queue<String> q1 = new PriorityQueue();  
2. Queue<String> q2 = new ArrayDeque();  

There are various classes that implement the Queue interface, some of them are given below.

Priority Queue

The Priority Queue class implements the Queue interface. It holds the elements or objects which are to be processed by their priorities. Priority Queue doesn't allow null values to be stored in the queue.

Consider the following example.

1. Import java.util.*;  
2. Public class TestJavaCollection5{  
3. Public static void main(String args[]){  
4. PriorityQueue<String> queue=new PriorityQueue<String>();  
5. Queue.add("Amit Sharma");  
6. Queue.add("Vijay Raj");  
7. Queue.add("JaiShankar");  
8. Queue.add("Raj");  
9. System.out.println("head:"+queue.element());  
10. System.out.println("head:"+queue.peek());  
11. System.out.println("iterating the queue elements:");  
12. Iterator itr=queue.iterator();  
13. While(itr.hasNext()){  
14. System.out.println(itr.next());  
15. }  
16. Queue.remove();  
17. Queue.poll();  
18. System.out.println("after removing two elements:");  
19. Iterator<String> itr2=queue.iterator();  
20. While(itr2.hasNext()){  
21. System.out.println(itr2.next());  
22. }  
23. }  
24. }  

Output:

Head:Amit Sharma

Head:Amit Sharma

Iterating the queue elements:

Amit Sharma

Raj

JaiShankar

Vijay Raj

After removing two elements:

Raj

Vijay Raj

Deque Interface

Deque interface extends the Queue interface. In Deque, we can remove and add the elements from both the side. Deque stands for a double-ended queue which enables us to perform the operations at both the ends.

Deque can be instantiated as:

Deque d = new ArrayDeque();  

ArrayDeque

ArrayDeque class implements the Deque interface. It facilitates us to use the Deque. Unlike queue, we can add or delete the elements from both the ends.

ArrayDeque is faster than ArrayList and Stack and has no capacity restrictions.

Consider the following example.

1. Import java.util.*;  
2. Public class TestJavaCollection6{  
3. Public static void main(String[] args) {  
4. //Creating Deque and adding elements  
5. Deque<String> deque = new ArrayDeque<String>();  
6. Deque.add("Gautam");  
7. Deque.add("Karan");  
8. Deque.add("Ajay");  
9. //Traversing elements  
10. For (String str : deque) {  
11. System.out.println(str);  
12. }  
13. }  
14. }  

Output:

Gautam

Karan

Ajay

5.2 List interface and its classes

List in Java provides the facility to maintain the ordered collection.

It contains the index-based methods to insert, update, delete and search the elements.

It can have the duplicate elements also. We can also store the null elements in the list.

The implementation classes of List interface are Array List, Linked List, Stack and Vector.

Declaration:

Public interface List<E> extends Collection<E>

Java List Methods:

Example:

1.   Creating a List of type String using ArrayList  

List<String> list=new ArrayList<String>();  

2.    Creating a List of type Integer using ArrayList  

List<Integer> list=new ArrayList<Integer>();

3.    Creating a List of type Book using ArrayList  

List<Book> list=new ArrayList<Book>();  

4.    Creating a List of type String using LinkedList  

List<String> list=new LinkedList<String>();  

List Example

Let's see a simple example of List where we are using the Array List class as the implementation.

Import java.util.*;  

Public class ListExample1{  

Public static void main(String args[]){  

//Creating a List  

List<String> list=new ArrayList<String>();  

//Adding elements in the List  

List.add("Mango");  

List.add("Apple");  

List.add("Banana");  

List.add("Grapes");  

//Iterating the List element using for-each loop  

For(String fruit:list)  

System.out.println(fruit);  

}  

}  

Output:

Mango

Apple

Banana

Grapes

How to convert Array to List

We can convert the Array to List by traversing the array and adding the element in list one by one using list.add() method. Let's see a simple example to convert array elements into List.

Import java.util.*;  

Public class ArrayToListExample{  

Public static void main(String args[]){  

//Creating Array  

String[] array={"Java","Python","PHP","C++"};  

System.out.println("Printing Array: "+Arrays.toString(array));  

//Converting Array to List  

List<String> list=new ArrayList<String>();  

For(String lang:array){  

List.add(lang);  

}  

System.out.println("Printing List: "+list);  

}  

}  

Output:

Printing Array: [Java, Python, PHP, C++]

Printing List: [Java, Python, PHP, C++]

How to convert List to Array

We can convert the List to Array by calling the list.toArray() method. Let's see a simple example to convert list elements into array.

Import java.util.*;  

Public class ListToArrayExample{  

Public static void main(String args[]){  

List<String> fruitList = new ArrayList<>();    

FruitList.add("Mango");    

FruitList.add("Banana");    

FruitList.add("Apple");    

FruitList.add("Strawberry");    

//Converting ArrayList to Array  

String[] array = fruitList.toArray(new String[fruitList.size()]);    

System.out.println("Printing Array: "+Arrays.toString(array));  

System.out.println("Printing List: "+fruitList);  

}  

}  

Output:

Printing Array: [Mango, Banana, Apple, Strawberry]

Printing List: [Mango, Banana, Apple, Strawberry]

Difference between List, Set, and Map interface:

The List, Set and Map interfaces are significant members of the Java

1. Ordering: -

1. List: - represents an ordered sequence in Java whose elements are accessible by index.
2. Set: - represents a distinct collection of elements in Java which can be either ordered or unordered, depending on the               implementation.

Example:  a) HashSet implementation is unordered

b) TreeSet implementation is ordered by natural order or provided comparator.

3.  Map: - represents the mapping of the key to values in Java. The ordering in Map is also implementation-specific

Example: Tree Map class is ordered while the HashMap class is not.

B.      Duplicates:

1. List: List can have duplicate elements
2. Set: A set contain only distinct elements
3. Map: Map doesn’t permit duplicate keys, i.e., each key can map to at most one value.

C.     Null Values:

1. List: It allows any number of null values
2. Set: a set contains at most one null element.
3. Map: Map typically allows null as a key and value, but some implementations prohibit null keys and values.

D.     Implementing Classes:

1. List: The most popular implementing classes of the List interface are Array List and LinkedList
2. Set: set interfaces included HashSet, TreeSet, Linked Hash Set
3. Map: Map interfaces offers Tree Map, Linked Hash Map, Tree Map

E.      When to use List, Map and Set:

1.   List:  List can be used when the insertion order of an elements need to be maintained.
2.   Set:   We can use set if we need to maintain a collection that contain no duplicates.
3.   Map: when data is key-value pairs and need fast retrieval of value based on some key.

Getter And Setter classes in java

Getter method:

• A method which is used to retrieve/get the value of a variable or return the value of the private member variable is called getter method in Java.
• This method is also known as accessor method. For every private variable, we should create a getter method.
• Depending on the access level giving to the variable, we can set the access modifier of its getter method.
• If we declare instance variables as private, we will have to add public getter methods for each one.
• The signature of a getter method in Java is as follows:

Public returnType getPropertyName()

• If the returnType is boolean, the getter method should defined

Public boolean isPropertyName()

5.3 Set interface and its classes

Set Interface in Java is present in java.util package.

It extends the Collection interface.

It represents the unordered set of elements which doesn't allow us to store the duplicate items. We can store at most one null value in Set. Set is implemented by HashSet, Linked Hash Set, and TreeSet.

Set can be instantiated as:

Set<data-type> s1 = new HashSet<data-type>();  

Set<data-type> s2 = new LinkedHashSet<data-type>();  

Set<data-type> s3 = new TreeSet<data-type>();

HashSet

HashSet class implements Set Interface. It represents the collection that uses a hash table for storage. Hashing is used to store the elements in the HashSet. It contains unique items.

Consider the following example.

Import java.util.*;  

Public class TestJavaCollection7{  

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:

Vijay

Ravi

Ajay

Linked Hash Set

Linked Hash Set class represents the LinkedList implementation of Set Interface. It extends the HashSet class and implements Set interface. Like HashSet, It also contains unique elements. It maintains the insertion order and permits null elements.

Consider the following example

Import java.util.*;  

Public class TestJavaCollection8{  

Public static void main(String args[]){  

LinkedHashSet<String> set=new LinkedHashSet<String>();  

Set.add("Ravi");  

Set.add("Vijay");  

Set.add("Ravi");  

Set.add("Ajay");  

Iterator<String> itr=set.iterator();  

While(itr.hasNext()){  

System.out.println(itr.next());  

}  

}  

}  

Output:

Ravi

Vijay

Ajay

TreeSet

Java TreeSet class implements the Set interface that uses a tree for storage. Like HashSet, TreeSet also contains unique elements. However, the access and retrieval time of TreeSet is quite fast. The elements in TreeSet stored in ascending order.

Consider the following example:

Import java.util.*;  

Public class TestJavaCollection9{  

Public static void main(String args[]){  

//Creating and adding elements  

TreeSet<String> set=new TreeSet<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

Ravi

Vijay

5.4 Map interface and its classes

A map contains values on the basis of key, i.e. key and value pair. Each key and value pair is known as an entry. A Map contains unique keys.

A Map is useful if you have to search, update or delete elements on the basis of a key.

Java Map Hierarchy

There are two interfaces for implementing Map in java: Map and Sorted Map, and three classes: HashMap, Linked Hash Map, and Tree Map. The hierarchy of Java Map is given below:

A Map doesn't allow duplicate keys, but you can have duplicate values. HashMap and Linked Hash Map allow null keys and values, but Tree Map doesn't allow any null key or value.

A Map can't be traversed, so you need to convert it into Set using keySet() or entrySet() method.

Useful methods of Map interface

Map Example

Import java.util.*;  

Class MapExample2{  

Public static void main(String args[]){  

Map<Integer,String> map=new HashMap<Integer,String>();  

Map.put(100,"Amit");  

Map.put(101,"Vijay");  

Map.put(102,"Rahul");  

//Elements can traverse in any order  

For(Map.Entry m:map.entrySet()){  

System.out.println(m.getKey()+" "+m.getValue());  

}  

}  

}  

Output:

102 Rahul

100 Amit

101 Vijay

Map Example: comparingByKey()

Import java.util.*;  

Class MapExample3{  

Public static void main(String args[]){  

Map<Integer,String> map=new HashMap<Integer,String>();          

Map.put(100,"Amit");    

Map.put(101,"Vijay");    

Map.put(102,"Rahul");   

//Returns a Set view of the mappings contained in this map        

Map.entrySet()  

//Returns a sequential Stream with this collection as its source  

.stream()  

//Sorted according to the provided Comparator  

.sorted(Map.Entry.comparingByKey())  

//Performs an action for each element of this stream  

.forEach(System.out::println);  

}  

}  

Output:

100=Amit

101=Vijay

102=Rahul

Map Example: comparingByKey() in Descending Order

Import java.util.*;  

Class MapExample4{  

Public static void main(String args[]){  

Map<Integer,String> map=new HashMap<Integer,String>();                map.put(100,"Amit");    

Map.put(101,"Vijay");    

Map.put(102,"Rahul");    

//Returns a Set view of the mappings contained in this map    

Map.entrySet()  

//Returns a sequential Stream with this collection as its source  

.stream()  

//Sorted according to the provided Comparator  

.sorted(Map.Entry.comparingByKey(Comparator.reverseOrder()))  

//Performs an action for each element of this stream  

.forEach(System.out::println);  

}  

}  

Output:

102=Rahul

101=Vijay

100=Amit

References:

1. Sun Certified Java Programmer for Java 6 by Kathy Sierra.

2. The Java TM Programming Language (3rd Edition) by Arnold, Holmes, Gosling, Goteti.

3. Core Java for Beginners by Rashmi Kanta Das(III Edition) Vikas Publication.

4. Java A Beginner's Guide, Fifth Edition, Tata McGra.