Java Collections Framework (JCF) provides powerful data structures that simplify complex programming tasks. In this blog series, we will explore all collection types and their methods in detail, ensuring you skip none!

1. ArrayList (java.util.ArrayList)

Overview

ArrayList is a resizable array implementation of the List interface. It allows random access, dynamic resizing, and provides fast read operations (O(1)) but slower insertions/deletions (O(n)).

Constructors 

ArrayList<Integer> list = new ArrayList<>(); // Default
ArrayList<Integer> list2 = new ArrayList<>(20); // With initial capacity
ArrayList<Integer> list3 = new ArrayList<>(list2); // Copying another list

Core Methods

Adding Elements 

list.add(10); // Appends element at the end
list.add(1, 20); // Inserts 20 at index 1

Removing Elements 

list.remove(1); // Removes element at index 1
list.remove(Integer.valueOf(10)); // Removes first occurrence of 10
list.clear(); // Removes all elements

Retrieving Elements 

int val = list.get(0); // Retrieves the first element

Updating Elements 

list.set(0, 99); // Updates the first element to 99

Searching Elements 

boolean exists = list.contains(99); // Returns true if 99 exists
int index = list.indexOf(99); // Returns index of first occurrence
int lastIndex = list.lastIndexOf(99); // Returns last occurrence

Checking Size and Emptiness 

int size = list.size(); // Returns number of elements
boolean isEmpty = list.isEmpty(); // Checks if empty

Iteration 

for (Integer num : list) { System.out.println(num); }

Conversion 

Object[] arr = list.toArray(); // Converts to Object array
Integer[] intArr = list.toArray(new Integer[0]); // Converts to Integer array

Sorting 

list.sort(Comparator.naturalOrder()); // Sorts in ascending order

2. LinkedList (java.util.LinkedList)

Overview

A LinkedList is a doubly linked list implementation of List and Deque. It allows fast insertions and deletions (O(1)) but slower access (O(n)).

Constructors 

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

Core Methods

Adding Elements 

linkedList.add("Apple"); // Adds at end
linkedList.addFirst("Orange"); // Adds at beginning
linkedList.addLast("Banana"); // Adds at end

Removing Elements 

linkedList.remove(); // Removes first element
linkedList.remove(1); // Removes element at index 1
linkedList.removeFirst(); // Removes first element
linkedList.removeLast(); // Removes last element

Retrieving Elements 

String first = linkedList.getFirst(); // Gets first element
String last = linkedList.getLast(); // Gets last element

Checking Size and Emptiness 

int size = linkedList.size();
boolean isEmpty = linkedList.isEmpty();

Iteration 

for (String item : linkedList) { System.out.println(item); }

Queue Methods (Inherited from Deque) 

linkedList.offer("Grapes"); // Adds element at end
String head = linkedList.poll(); // Retrieves and removes first element
String peekElement = linkedList.peek(); // Retrieves first element without removing

3. Queue (java.util.Queue)

Overview

A Queue follows FIFO (First-In-First-Out) principle. It is implemented by LinkedList and PriorityQueue.

Core Methods

Adding and Removing Elements 

Queue<Integer> queue = new LinkedList<>();
queue.offer(10); // Adds 10 to the queue
queue.offer(20);

Retrieving Elements 

int first = queue.poll(); // Retrieves and removes head element
int head = queue.peek(); // Retrieves head without removing

Checking Size and Emptiness 

int size = queue.size();
boolean isEmpty = queue.isEmpty();

4. Stack (java.util.Stack)

Overview

A Stack follows LIFO (Last-In-First-Out) principle. It extends Vector.

Core Methods

Adding and Removing Elements 

Stack<Integer> stack = new Stack<>();
stack.push(10); // Pushes element onto stack
stack.push(20);

Retrieving Elements 

int top = stack.peek(); // Returns top element without removing
int popped = stack.pop(); // Removes and returns top element

Checking if Empty 

boolean isEmpty = stack.empty();

Searching Elements 

int position = stack.search(10); // Returns 1-based position

Conclusion

This concludes Part 1 of our Java Collections deep dive. We covered ArrayList, LinkedList, Queue, and Stack, exploring all their methods with examples. Stay tuned for Part 2, where we will cover Deque, HashSet, and HashMap in detail!

🚀 Next Up: Java Collections Part 2 - Deque, HashSet, and HashMap