@techwithvishalraj

Java
Collections
Hierarchy of Collection Framework @techwithvishalraj
 @techwithvishalraj

Collections in Java

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.

The java.util package contains all the classes and interfaces for the
Collection framework except Iterable interface which is present in
java.lang package.
 List Interface
@techwithvishalraj

In List store the ordered collection of objects.

It can have duplicate values.
List interface is implemented by the classes ArrayList, LinkedList, Vector,
and Stack.

List <data-type> list1= new ArrayList();

List <data-type> list2 = new LinkedList();
List <data-type> list3 = new Vector();
List <data-type> list4 = new Stack();

Map Interface

A map contains 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.
A Map doesn't allow duplicate keys, but you can have duplicate values.
HashMap and LinkedHashMap allow null keys and values, but TreeMap
doesn't allow any null key or value.

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

Map<Integer,String> map = new TreeMap<Integer, String>();
 Set Interface @techwithvishalraj

A Set does not allow duplicate elements.

Sets typically do not guarantee any specific order for their elements.

Set<String> set= new HashSet<>();

Set<String> set = new LinkedHashSet<>();
Set<Integer> set= new TreeSet<>();

Queue Interface

A queue is a linear data structure that follows the "first-in, first-out" (FIFO)
principle.
It is an ordered list of objects.

Queue<String> queue = new PriorityQueue<>();

Queue<String> list = new LinkedList<>();
Queue<String> deque = new ArrayDeque<>();
 ArrayList Class
@techwithvishalraj

ArrayList can grow or shrink dynamically as elements are added or removed.

You can access elements in an ArrayList using an index. The index starts at 0
for the first element and goes up to size() - 1 for the last element.
ArrayList can contain duplicate elements.
Elements in an ArrayList maintain the order in which they were added.

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

list.add(1);
list.add(5);

System.out.println(list); ----> [1, 5]

list.size() ----> 2
list.isEmpty() ----> false
list.remove(1) ----> 1 is the index
list.toString() ----> [1, 5]

list.contains(1) -----> true

Object[] arr=list.toArray(); ----> [1, 5]
list.add(1, 9); ----> [1, 9, 5]
list.clear();

list.addAll(list1);
 LinkedList Class
@techwithvishalraj

LinkedList is a class that implements the List interface and is used to create
and manipulate doubly-linked lists.
A doubly-linked list is a data structure in which each element is a node that
contains a reference to both the next and previous nodes in the list.

LinkedList<String> linkedList = new LinkedList<>();

linkedList.add("First");
linkedList.addLast("Last");
linkedList.addFirst("NewFirst");

String firstElement = linkedList.getFirst();

String lastElement = linkedList.getLast();
String secondElement = linkedList.get(1);

linkedList.remove("First");
linkedList.removeFirst();
linkedList.removeLast();

boolean containsElement = linkedList.contains("First");

int size = linkedList.size();
boolean isEmpty = linkedList.isEmpty();
linkedList.clear();
 Stack Class @techwithvishalraj

Stack class follows the "last-in, first-out" (LIFO) principle.

If the stack is empty, it throws an EmptyStackException.

Stack<Integer> stack = new Stack<>();

stack.push(10);
stack.push(20);
stack.push(30);

int topElement = stack.peek();

int poppedElement = stack.pop();

boolean isEmpty = stack.empty();

int position = stack.search(20); ----> return position from the top of

the stack and if not found return -1.
 Vector Class @techwithvishalraj

Vector is a legacy data structure in Java that is similar to an ArrayList.

It is part of the Java Collections Framework and provides dynamic array-like
functionality.
However, Vector is synchronized by default, which means it is thread-safe but
may be less efficient than ArrayList in single-threaded scenarios.

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

numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(1, 25);

int size = numbers.size();

int firstNumber = numbers.get(0);

numbers.remove(2);
numbers.clear();

boolean containsElement = numbers.contains(10);

boolean isEmpty = numbers.isEmpty();
 PriorityQueue Class @techwithvishalraj

Elements with higher priority are dequeued before elements with lower priority.
The priority queue processes elements in ascending order by default.

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

priorityQueue.add(5);
priorityQueue.add(2);
priorityQueue.add(8);
priorityQueue.add(1);

// Retrieving and removing the highest priority element

int highestPriority = priorityQueue.poll(); ----> 1

int peekedElement = priorityQueue.peek(); ----> 2

// Checking if an element exists and removing it

boolean removed = priorityQueue.remove(8); ----> true/false

int size = priorityQueue.size(); ----> 2

boolean isEmpty = priorityQueue.isEmpty(); ----> true/false

// Iterating through the PriorityQueue(ascending order by default)

while (!priorityQueue.isEmpty()) {
System.out.println(priorityQueue.poll()); ----> 2 4 5
}
 ArrayDeque Class @techwithvishalraj

ArrayDeque is a double-ended queue implementation in Java that provides

methods for adding and removing elements from both ends efficiently.

ArrayDeque<Integer> deque = new ArrayDeque<>();

deque.addFirst(1);
deque.addLast(2);
deque.offerFirst(4);
deque.offerLast(3);

int frontElement = deque.getFirst();

int rearElement = deque.getLast();

int removedFront = deque.removeFirst();

int removedRear = deque.removeLast();

int size = deque.size();

boolean isEmpty = deque.isEmpty();
deque.clear();

Note:
addFirst() may throw an exception if the deque is full.
offerFirst() returns false if the element cannot be added due to
capacity constraints but does not throw an exception.
 HashSet Class
@techwithvishalraj

HashSet is an implementation of the Set interface that provides a collection

of unique elements.
It is used to store a group of distinct values without any specific order.

Set<String> set= new HashSet<>();

set.add("Apple");
set.add("Banana");
set.add("Cherry");

for (String fruit : set) {

System.out.println(fruit); ----> Apple Cherry Banana
}

set.remove("Banana");

boolean containsCherry = set.contains("Cherry");

int size = set.size();

set.clear();
 LinkedHashSet Class @techwithvishalraj

LinkedHashSet combines the features of both a HashSet and a

LinkedHashMap.
It maintains a collection of unique elements like a HashSet, but it also
preserves the order of insertion like a LinkedHashMap. This means that when
you iterate over a LinkedHashSet, the elements are returned in the order in
which they were added.

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

set.add("Apple");
set.add("Banana");
set.add("Cherry");

for (String fruit : set) {

System.out.println(fruit); ----> Apple Banana Cherry
}

int size = set.size();

set.remove("Banana");

boolean containsCherry = set.contains("Cherry");

 TreeSet Class
@techwithvishalraj

TreeSet is that it maintains its elements in sorted order.

TreeSet does not allow duplicate elements.
TreeSet uses a Red-Black Tree data structure to maintain its elements in a
sorted manner.
TreeSet provides methods to navigate through the set, such as lower(), floor(),
ceiling(), and higher(), which allow you to find elements that are less than, less
than or equal to, greater than or equal to, or greater than a given element,
respectively.

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

numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
numbers.add(4);

System.out.println(numbers); -----> [1, 2, 4, 5, 8]

System.out.println(numbers.higher(4)); -----> 5
System.out.println(numbers.lower(4)); -----> 2

boolean containsFive = numbers.contains(5); -----> true/false

numbers.isEmpty(); -----> true/false
numbers.remove(2);
int size = numbers.size(); ------> 4
 TreeMap Class
@techwithvishalraj

TreeMap implements the Map interface and is based on a Red-Black Tree.

Maintains the key-value pairs in sorted order based on the keys.
Each key in a TreeMap must be unique, but values can be duplicated.
Attempting to add a duplicate key will replace the existing value associated with
that key.
A HashMap allows null values but not null key.

TreeMap<Integer, String> treeMap = new TreeMap<>();

treeMap.put(3, "Three");
treeMap.put(1, "One");
treeMap.put(2, "Two");

String value = treeMap.get(2); -------> Two

for (Integer key : treeMap.keySet()) {

System.out.print(key + ": " + treeMap.get(key)); 1: One 2: Two 3: Three
}

boolean containsKey = treeMap.containsKey(4); -------> true/false

treeMap.remove(1);
int size = treeMap.size(); -------> 2
treeMap.isEmpty();
treeMap.clear();
 HashMap Class
@techwithvishalraj

HashMap is store and manage data in key-value pairs.

A HashMap is based on the principle of a hash table, which allows for fast
retrieval and insertion of data.
keys must be unique within a HashMap, values can be duplicated.
HashMap does not guarantee any specific order.
A HashMap allows null values and a single null key.

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

scores.put("Alice", 95);
scores.put("Bob", 88);
scores.put("Charlie", 92);

int aliceScore = scores.get("Alice"); ------> 95

boolean hasKey = scores.containsKey("Bob"); ------> true/false

for (String key : scores.keySet()) {

System.out.print(key+": "+scores.get(key)); ---> Bob: 88 Alice: 95 Charlie: 92
}

scores.remove("Charlie");

int size = scores.size(); ------> 2

scores.isEmpty() ------> true/false
scores.clear();
 LinkedHashMap Class
@techwithvishalraj

In LinkedHashMap, the elements are returned in the order in which they were
added to the map or in the order in which they were most recently accessed,
depending on the constructor used.
keys must be unique, values can be duplicated.
It allows null keys and values.

// true parameter in below constructor means access-order enable

LinkedHashMap<String, Integer> map = new LinkedHashMap<>(16, 0.75f, true);
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
// Access an element (this moves it to the end of the access-order)
map.get("One");
// Iterate through the elements (in access-order)
for (Map.Entry<String, Integer> entry : map.entrySet()) {
Sop(entry.getKey() +":"+ entry.getValue()); -----> Two: 2 Three: 3 One: 1
}

// no parameter constructor means insertion-order

LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
map.get("One");
for (String key : map.keySet()) {
System.out.println(key + ": " + map.get(key)); -----> One: 1 Two: 2 Three: 3
}
 Iterator Interface
@techwithvishalraj

Present in the java.util package.

iterator is an object that allows you to traverse and manipulate elements in a
collection (such as lists, sets, or maps) in a consistent and standardized way.

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

fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
iterator.remove();
System.out.println(fruit);
}
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 22);
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println("Key: " + key + ", Value: " + value);
}
 Collections Class
@techwithvishalraj

Present in the java.util package.

Collections class uses only static methods for computations.

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

list.add(1);
list.add(6);
list.add(0);

Collections.addAll(list, 8, 3);
Integer[] arr = {5, 4, 1};
Collections.addAll(list, arr);

System.out.println(list);
int max=Collections.max(list);
int min=Collections.min(list);
int frequency=Collections.frequency(list, 1);
int index = Collections.binarySearch(list, 4);
System.out.println(max+" "+ min +" "+ frequency+" "+ index);
Collections.reverse(list);
System.out.println(list);
 Thank
you!

EXPLORE MORE

@techwithvishalraj