JAVA COLLECTIONS FRAMEWORK

 Provides a set of interfaces and classes to

implement various data structures and algorithms.
Interfaces of Collections FrameWork
Java Collection Interface
 The Collection interface is the root interface of the
collections framework hierarchy.
 Java does not provide direct implementations of
the Collection interface
 But provides implementations of its subinterfaces
like List, Set, and Queue.
Collections Framework Vs. Collection Interface

 People often get confused between the collections

framework and Collection Interface.
 The Collection interface is the root interface of the
collections framework.
 The framework includes other interfaces as
well: Map and Iterator. These interfaces may also
have subinterfaces.
Subinterfaces of the Collection Interface

List Interface: The List interface is an ordered

collection that allows us to add and remove
elements like an array.

Set Interface: The Set interface allows us to store

elements in different sets similar to the set in
mathematics. It cannot have duplicate elements.

Queue Interface : The Queue interface is used when we want

to store and access elements in First In, First Out manner.
Java Map Interface :
 In Java, the Map interface allows elements to be

stored in key/value pairs.

 Keys are unique names that can be used to access a

particular element in a map.

 Each key has a single value associated with it.

Java Iterator Interface: Provides methods that can be

used to access elements of collections.
Why the Collections Framework?
 Provides various data structures and algorithms that
can be used directly.
This has two main advantages:
 We do not have to write code to implement these

data structures and algorithms manually.

 Our code will be much more efficient as the

collections framework is highly optimized.

 Allows us to use a specific data structure for a
particular type of data.
Here are a few examples,
 If we want our data to be unique, then we can use
the Set interface provided by the collections
framework.
 To store data in key/value pairs, we can use
the Map interface.
 The ArrayList class provides the functionality of
resizable arrays.
Java Collection Interface
 The Collection interface is the root interface of the
Java collections framework.
 There is no direct implementation of this interface.
However, it is implemented through its subinterfaces
like List, Set, and Queue.
 For example, the ArrayList class implements
the List interface which is a subinterface of
the Collection Interface.
Subinterfaces of the Collection Interface

List Interface: The List interface is an ordered

collection that allows us to add and remove
elements like an array.

Set Interface: The Set interface allows us to store

elements in different sets similar to the set in
mathematics. It cannot have duplicate elements.

Queue Interface : The Queue interface is used when we want

to store and access elements in First In, First Out manner.
Methods of Collection
 The Collection interface includes various methods
that can be used to perform different operations on
objects.
 These methods are available in all its subinterfaces.
1. add() - inserts the specified element to the
collection
2. size() - returns the size of the collection
3. remove() - removes the specified element from the
collection
4. iterator() - returns an iterator to access elements of
the collection
5. addAll() - adds all the elements of a specified
collection to the collection
6. removeAll() - removes all the elements of the
specified collection from the collection
7. clear() - removes all the elements of the collection
 Java List
 The List interface is an ordered collection that allows us to
store and access elements sequentially.
 It extends the Collection interface.

Classes that Implement List

 Since List is an interface, we cannot create objects from it.

 In order to use the functionalities of the List interface, we

can use these classes:
1. ArrayList
2. LinkedList
3. Vector
4. Stack
 These classes are defined in the Collections
framework and implement the List interface.
How to use List?
 In Java, we must import java.util.List package in
order to use List.

// ArrayList implementation of List

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

// LinkedList implementation of List

List<String> list2 = new LinkedList<>();
Methods of List
 The List interface includes all the methods of
the Collection interface. Its because Collection is a
super interface of List.
 Commonly used methods of the Collection interface
that's also available in the List interface are:
add() - adds an element to a list
addAll() - adds all elements of one list to another
get() - helps to randomly access elements from lists
iterator() - returns iterator object that can be used to
sequentially access elements of lists
set() - changes elements of lists
remove() - removes an element from the list
removeAll() - removes all the elements from the list
clear() - removes all the elements from the list (more
efficient than removeAll())
size() - returns the length of lists
toArray() - converts a list into an array
contains() - returns true if a list contains specific element
1. Implementing the ArrayList
Class
import java.util.List; Output
import java.util.ArrayList;
class Main {
public static void main(String[] args) { List: [1, 2, 3]
// Creating list using the ArrayList class
List<Integer> numbers = new ArrayList<>(); Accessed Element: 3
// Add elements to the list Removed Element: 2
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("List: " + numbers);

// Access element from the list

int number = numbers.get(2);
System.out.println("Accessed Element: " + number);

// Remove element from the list

int removedNumber = numbers.remove(1);
System.out.println("Removed Element: " + removedNumber);
}
}
Implementing the LinkedList Class
import java.util.List;
import java.util.LinkedList; Output
class Main {
public static void main(String[] args) {
List: [1, 2, 3]
// Creating list using the LinkedList class Accessed Element: 3
List<Integer> numbers = new LinkedList<>();
// Add elements to the list Position of 3 is 1
numbers.add(1); Removed Element: 2
numbers.add(2);
numbers.add(3);
System.out.println("List: " + numbers);
// Access element from the list
int number = numbers.get(2);
System.out.println("Accessed Element: " + number);

// Using the indexOf() method

int index = numbers.indexOf(2);
System.out.println("Position of 3 is " + index);
// Remove element from the list
int removedNumber = numbers.remove(1);
System.out.println("Removed Element: " + removedNumber);
}
Java List vs. Set
 Both the List interface and the Set interface inherit
the Collection interface. However, there exists some
difference between them.
 Lists can include duplicate elements. However, sets
cannot have duplicate elements.
 Elements in lists are stored in some order. However,
elements in sets are stored in groups like sets in
mathematics.
 Java ListIterator Interface
 The ListIterator interface of the Java collections
framework provides the functionality to access
elements of a list.
 It is bidirectional. This means it allows us to iterate
elements of a list in both the direction.
 It extends the Iterator interface.

 The List interface provides a

listIterator() method that returns

an instance of the ListIterator
interface.
Methods of ListIterator
 hasNext() - returns true if there exists an element in the list
 next() - returns the next element of the list
 nextIndex() returns the index of the element that the next()
method will return
 previous() - returns the previous element of the list
 previousIndex() - returns the index of the element that the
previous() method will return
 remove() - removes the element returned by either next() or
previous()
 set() - replaces the element returned by either next() or
previous() with the specified element
Implementation of ListIterator
import java.util.ArrayList;
import java.util.ListIterator; OUTPUT:
class Main { ArrayList: [1, 3, 2]
public static void main(String[] args) { Next Element: 1
// Creating an ArrayList Position of Next Element: 1
ArrayList<Integer> numbers = new ArrayList<>(); Is there any next element? true
numbers.add(1);
numbers.add(3);
numbers.add(2);
System.out.println("ArrayList: " + numbers);
// Creating an instance of ListIterator
ListIterator<Integer> iterate = numbers.listIterator();
// Using the next() method
int number1 = iterate.next();
System.out.println("Next Element: " + number1);

// Using the nextIndex()

int index1 = iterate.nextIndex();
System.out.println("Position of Next Element: " + index1);
// Using the hasNext() method
System.out.println("Is there any next element? " + iterate.hasNext());
}
}
Java ArrayList
 In Java, we use the ArrayList class to implement the
functionality of resizable-arrays.
 It implements the List interface of the collections
framework.
Java ArrayList Vs Array
 In Java, we need to declare the size of
an array before we can use it. Once the size of an
array is declared, it's hard to change it.
 To handle this issue, we can use the ArrayList class. It
allows us to create resizable arrays.
 Unlike arrays, arraylists can automatically adjust
their capacity when we add or remove elements
from them. Hence, arraylists are also known
as dynamic arrays.
Create ArrayList in Java
import java.util.ArrayList;

class Main {
public static void main(String[] args){

// create ArrayList
ArrayList<String> languages = new ArrayList<>();

// Add elements to ArrayList

languages.add("Java");
languages.add("Python");
languages.add("Swift");
System.out.println("ArrayList: " + languages);
}
}
OUTPUT: ArrayList: [Java, Python, Swift]
Basic Operations on ArrayList
 The ArrayList class provides various methods to
perform different operations on arraylists. We will
look at some commonly used arraylist operations in
this tutorial:
1. Add elements
2. Access elements
3. Change elements
4. Remove elements
1. Add Elements to an ArrayList
import java.util.ArrayList;
class Main {
public static void main(String[] args){
ArrayList<String> languages = new ArrayList<>();
languages.add("Java");
languages.add("C");
languages.add("Python");
System.out.println("ArrayList: " + languages);
}
}
2. Access ArrayList Elements
 To access an element from the arraylist, we use
the get() method of the ArrayList class. For example,
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();
// add elements in the arraylist
animals.add("Cat");
animals.add("Dog");
animals.add("Cow");
System.out.println("ArrayList: " + animals);

// get the element from the arraylist

String str = animals.get(1);
System.out.print("Element at index 1: " + str);
}
}
OUTPUT:
ArrayList: [Cat, Dog, Cow]
Element at index 1: Dog
3. Change ArrayList Elements
 To change elements of the arraylist, we use
the set() method of the ArrayList class.
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
ArrayList<String> languages = new ArrayList<>();

// add elements in the array list

languages.add("Java");
languages.add("Kotlin");
languages.add("C++");
System.out.println("ArrayList: " + languages);

// change the element of the array list

languages.set(2, "JavaScript");
System.out.println("Modified ArrayList: " + languages);
}
}
ArrayList: [Java, Kotlin, C++]
Modified ArrayList: [Java, Kotlin, JavaScript]
4. Remove ArrayList Elements
 To remove an element from the arraylist, we can use
the remove() method of the ArrayList class.
import java.util.ArrayList;

class Main {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();

// add elements in the array list

animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("ArrayList: " + animals);

// remove element from index 2

String str = animals.remove(2);
System.out.println("Updated ArrayList: " + animals);
System.out.println("Removed Element: " + str);
}
}
ArrayList: [Dog, Cat, Horse]
Updated ArrayList: [Dog, Cat]
Removed Element: Horse
 Methods of ArrayList Class
size()- Returns the length of the arraylist.
sort()- Sort the arraylist elements.
clone()- Creates a new arraylist with the same element,
size, and capacity.
contains()- Searches the arraylist for the specified element
and returns a boolean result.
ensureCapacity()- Specifies the total element the arraylist
can contain.
isEmpty()- Checks if the arraylist is empty.
indexOf()- Searches a specified element in an arraylist
and returns the index of the element.
 Output:
Iterate through an ArrayList
import java.util.ArrayList; ArrayList: [Cow, Cat, Dog]
Accessing individual elements:
class Main {
public static void main(String[] args) { Cow, Cat, Dog,
// creating an array list
ArrayList<String> animals = new ArrayList<>();
animals.add("Cow");
animals.add("Cat");
animals.add("Dog");
System.out.println("ArrayList: " + animals);

// iterate using for-each loop

System.out.println("Accessing individual elements: ");

for (String language : animals) {

System.out.print(language);
System.out.print(", ");
}
}
}
Java Vector vs. ArrayList
 In Java, both ArrayList and Vector implements
the List interface and provides the same
functionalities.
 However, there exist some differences between
them.
 The Vector class synchronizes each individual
operation. This means whenever we want to perform
some operation on vectors, the Vector class
automatically applies a lock to that operation.
 It is because when one thread is accessing a vector,
and at the same time another thread tries to access
it, an exception
called ConcurrentModificationException is
generated. Hence, this continuous use of lock for
each operation makes vectors less efficient.
 However, in array lists, methods are not
synchronized. Instead, it uses
the Collections.synchronizedList() method that
synchronizes the list as a whole.
import java.util.Vector;

class Main {
Initial Vector: [Dog, Horse, Cat]
public static void main(String[] args) { Removed Element: Horse
Vector<String> animals= new Vector<>(); New Vector: [Dog, Cat]
animals.add("Dog"); Vector after clear(): []
animals.add("Horse");
animals.add("Cat");

System.out.println("Initial Vector: " + animals);

// Using remove()
String element = animals.remove(1);
System.out.println("Removed Element: " + element);
System.out.println("New Vector: " + animals);

// Using clear()
animals.clear();
System.out.println("Vector after clear(): " + animals);
}
}
Java Stack Class
 Initial Stack: [Dog, Horse, Cat]
import java.util.Stack;
Removed Element: Cat
class Main {
public static void main(String[] args) {
Stack<String> animals= new Stack<>();

// Add elements to Stack

animals.push("Dog");
animals.push("Horse");
animals.push("Cat");
System.out.println("Initial Stack: " + animals);

// Remove element stacks

String element = animals.pop();
System.out.println("Removed Element: " + element);
}
}
Java PriorityQueue
 Unlike normal queues, priority queue elements are
retrieved in sorted order.
 Suppose, we want to retrieve elements in the
ascending order. In this case, the head of the
priority queue will be the smallest element. Once
this element is retrieved, the next smallest element
will be the head of the queue.
 It is important to note that the elements of a priority
queue may not be sorted. However, elements are
always retrieved in sorted order.
import java.util.PriorityQueue;

class Main {
public static void main(String[] args) {

// Creating a priority queue

PriorityQueue<Integer> numbers = new PriorityQueue<>();
numbers.add(4);
numbers.add(2);
numbers.add(1);
System.out.println("PriorityQueue: " + numbers);

// Using the peek() method

int number = numbers.peek();
System.out.println("Accessed Element: " + number);
}
}
PriorityQueue: [1, 4, 2]
Accessed Element: 1
Java Map Interface
 The Map interface of the Java collections
framework provides the functionality of the map
data structure.
 In Java, elements of Map are stored
in key/value pairs. Keys are unique values
associated with individual Values.
 A map cannot contain duplicate keys. And, each key
is associated with a single value.
 We can access and modify values using the keys
associated with them.
 In the above diagram, we have values: United
States, Brazil, and Spain. And we have
corresponding keys: us, br, and es.
 We can access those values using their
corresponding keys.
Note: The Map interface maintains 3 different sets:
1. the set of keys
2. the set of values
3. the set of key/value associations (mapping).
Classes that implement Map
 Since Map is an interface, we cannot
create objects from it.
 In order to use the functionalities of the Map interface,
we can use these classes:
1. HashMap
2. EnumMap
3. LinkedHashMap
4. WeakHashMap
5. TreeMap
 These classes are defined in the collections framework
and implemented in the Map interface.
Methods of Map
 put(K, V) - Inserts the association of a key K
and a value V into the map. If the key is
already present, the new value replaces the
old value.
 get(K) - Returns the value associated with the
specified key K. If the key is not found, it
returns null.
Methods of Map

 containsKey(K) - Checks if the specified

key K is present in the map or not.
 containsValue(V) - Checks if the specified

value V is present in the map or not.

 replace(K, V) - Replace the value of the

key K with the new specified value V.

 remove(K) - Removes the entry from the
map represented by the key K.
Methods of Map
 remove(K, V) - Removes the entry from the map
that has key K associated with value V.
 keySet() - Returns a set of all the keys present
in a map.
 values() - Returns a set of all the values present
in a map.
 entrySet() - Returns a set of all the key/value

mapping present in a map.

Implementing HashMap Class
import java.util.Map;
import java.util.HashMap;
class Main {

public static void main(String[] args) {

// Creating a map using the HashMap
Map<String, Integer> numbers = new HashMap<>();

// Insert elements to the map

numbers.put("One", 1);
numbers.put("Two", 2);
System.out.println("Map: " + numbers);

// Access keys of the map

System.out.println("Keys: " + numbers.keySet());

// Access values of the map

System.out.println("Values: " + numbers.values());

// Access entries of the map

System.out.println("Entries: " + numbers.entrySet());

// Remove Elements from the map

int value = numbers.remove("Two");
System.out.println("Removed Value: " + value);
}
}
OUTPUT:

Map: {One=1, Two=2}

Keys: [One, Two]
Values: [1, 2]
Entries: [One=1, Two=2]
Removed Value: 2
Java Set Interface
 The Set interface of the Java Collections framework
provides the features of the mathematical set in
Java. It extends the Collection interface.
 Unlike the List interface, sets cannot contain
duplicate elements.
Set Operations
 The Java Set interface allows us to perform basic
mathematical set operations like union, intersection, and
subset.

 Union - to get the union of two sets x and y, we can use

x.addAll(y)
 Intersection - to get the intersection of two sets x and y,
we can use x.retainAll(y)
 Subset - to check if x is a subset of y, we can use
y.containsAll(x)
Java HashSet Class
 The HashSet class of the Java Collections
framework provides the functionalities of the hash
table data structure.
// HashSet with 8 capacity and 0.75 load factor
HashSet<Integer> numbers = new HashSet<>(8, 0.75);

 Notice, the part new HashSet<>(8, 0.75). Here, the first

parameter is capacity, and the second parameter
is loadFactor.
 capacity - The capacity of this hash set is 8. Meaning, it
can store 8 elements.
 loadFactor - The load factor of this hash set is 0.6. This
means, whenever our hash set is filled by 60%, the
elements are moved to a new hash table of double the
size of the original hash table.
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumber = new HashSet<>();

// Using add() method

evenNumber.add(2);
evenNumber.add(4);
evenNumber.add(6);
System.out.println("HashSet: " + evenNumber);

HashSet<Integer> numbers = new HashSet<>();

// Using addAll() method

numbers.addAll(evenNumber);
numbers.add(5);
System.out.println("New HashSet: " + numbers);
}
}
OUTPUT:
HashSet: [2, 4, 6]
New HashSet: [2, 4, 5, 6]