Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Comprehensive Java Collections practice programs covering List, Set, Map, Queue operations with solutions, explanations, and time complexity analysis.
Program 1: Remove Duplicates While Preserving Order
Problem: Given a list with duplicates, remove duplicates while maintaining insertion order.
java example
import java.util.*;
public class RemoveDuplicates {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(4, 2, 3, 2, 1, 4, 3, 5, 1);
// Method 1: LinkedHashSet preserves insertion order
List<Integer> unique = new ArrayList<>(new LinkedHashSet<>(numbers));
System.out.println("Unique: " + unique);
// Method 2: Stream with distinct()
List<Integer> unique2 = numbers.stream()
.distinct()
.collect(Collectors.toList());
System.out.println("Unique (stream): " + unique2);
// Method 3: Manual with Set tracking
List<Integer> unique3 = new ArrayList<>();
Set<Integer> seen = new HashSet<>();
for (int num : numbers) {
if (seen.add(num)) { // add() returns true if element was new
unique3.add(num);
}
}
System.out.println("Unique (manual): " + unique3);
}
}Output:
| Unique | [4, 2, 3, 1, 5] |
| Unique (stream) | [4, 2, 3, 1, 5] |
| Unique (manual) | [4, 2, 3, 1, 5] |
Time Complexity: O(n) for all methods | Space: O(n) for the Set
Program 3: Sort a Map by Values
Problem: Sort a HashMap by its values in descending order.
java example
import java.util.*;
import java.util.stream.*;
public class SortMapByValue {
public static void main(String[] args) {
Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 92);
scores.put("Bob", 88);
scores.put("Charlie", 95);
scores.put("Diana", 91);
scores.put("Eve", 88);
// Method 1: Using Stream (Java 8+)
LinkedHashMap<String, Integer> sorted = scores.entrySet().stream()
.sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
.collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue,
(e1, e2) -> e1,
LinkedHashMap::new
));
System.out.println("Sorted by value (desc): " + sorted);
// Method 2: Using List of entries
List<Map.Entry<String, Integer>> entries = new ArrayList<>(scores.entrySet());
entries.sort((a, b) -> b.getValue() - a.getValue());
System.out.println("Top scorers:");
entries.forEach(e -> System.out.println(" " + e.getKey() + ": " + e.getValue()));
}
}Output:
| Sorted by value (desc) | {Charlie=95, Alice=92, Diana=91, Bob=88, Eve=88} |
| Charlie | 95 |
| Alice | 92 |
| Diana | 91 |
| Bob | 88 |
| Eve | 88 |
Program 4: Find Intersection and Union of Two Lists
Example
import java.util.*;
import java.util.stream.*;
public class SetOperations {
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> list2 = Arrays.asList(4, 5, 6, 7, 8, 9);
// Intersection
Set<Integer> intersection = new HashSet<>(list1);
intersection.retainAll(list2);
System.out.println("Intersection: " + intersection); // [4, 5, 6]
// Union
Set<Integer> union = new HashSet<>(list1);
union.addAll(list2);
System.out.println("Union: " + union); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
// Difference (in list1 but not list2)
Set<Integer> difference = new HashSet<>(list1);
difference.removeAll(list2);
System.out.println("Difference (1-2): " + difference); // [1, 2, 3]
// Symmetric difference (in either but not both)
Set<Integer> symDiff = new HashSet<>(union);
symDiff.removeAll(intersection);
System.out.println("Symmetric diff: " + symDiff); // [1, 2, 3, 7, 8, 9]
}
}
Output
Intersection: [4, 5, 6] Union: [1, 2, 3, 4, 5, 6, 7, 8, 9] Difference (1-2): [1, 2, 3] Symmetric diff: [1, 2, 3, 7, 8, 9]
Program 5: LRU Cache Using LinkedHashMap
Problem: Implement a Least Recently Used (LRU) cache.
java example
import java.util.*;
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
private final int capacity;
public LRUCache(int capacity) {
super(capacity, 0.75f, true); // true = access-order
this.capacity = capacity;
}
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > capacity; // Remove oldest when over capacity
}
public static void main(String[] args) {
LRUCache<String, Integer> cache = new LRUCache<>(3);
cache.put("A", 1);
cache.put("B", 2);
cache.put("C", 3);
System.out.println(cache); // {A=1, B=2, C=3}
cache.get("A"); // Access A — moves to end
System.out.println(cache); // {B=2, C=3, A=1}
cache.put("D", 4); // B is evicted (least recently used)
System.out.println(cache); // {C=3, A=1, D=4}
cache.put("E", 5); // C is evicted
System.out.println(cache); // {A=1, D=4, E=5}
}
}Output
{A=1, B=2, C=3}
{B=2, C=3, A=1}
{C=3, A=1, D=4}
{A=1, D=4, E=5}Time Complexity: O(1) for get and put operations.
Program 6: Find First Non-Repeated Character
Example
import java.util.*;
public class FirstNonRepeated {
public static void main(String[] args) {
String input = "swiss";
// Method 1: LinkedHashMap preserves insertion order
Map<Character, Integer> charCount = new LinkedHashMap<>();
for (char c : input.toCharArray()) {
charCount.merge(c, 1, Integer::sum);
}
char result = charCount.entrySet().stream()
.filter(e -> e.getValue() == 1)
.map(Map.Entry::getKey)
.findFirst()
.orElse('\0');
System.out.println("First non-repeated: " + result); // w
// Method 2: Using indexOf and lastIndexOf
for (int i = 0; i < input.length(); i++) {
char c = input.charAt(i);
if (input.indexOf(c) == input.lastIndexOf(c)) {
System.out.println("First non-repeated (v2): " + c); // w
break;
}
}
}
}
Output
First non-repeated: w First non-repeated (v2): w
Program 7: Group Objects by Property
Problem: Group a list of employees by department.
java example
import java.util.*;
import java.util.stream.*;
record Employee(String name, String department, double salary) {}
public class GroupByDemo {
public static void main(String[] args) {
List<Employee> employees = Arrays.asList(
new Employee("Alice", "Engineering", 95000),
new Employee("Bob", "Marketing", 85000),
new Employee("Charlie", "Engineering", 92000),
new Employee("Diana", "Marketing", 88000),
new Employee("Eve", "Engineering", 98000),
new Employee("Frank", "HR", 75000)
);
// Group by department
Map<String, List<Employee>> byDept = employees.stream()
.collect(Collectors.groupingBy(Employee::department));
byDept.forEach((dept, emps) -> {
System.out.println(dept + ": " + emps.size() + " employees");
emps.forEach(e -> System.out.println(" - " + e.name()));
});
// Average salary by department
Map<String, Double> avgSalary = employees.stream()
.collect(Collectors.groupingBy(
Employee::department,
Collectors.averagingDouble(Employee::salary)
));
System.out.println("\nAverage salaries: " + avgSalary);
// Highest paid per department
Map<String, Optional<Employee>> topEarner = employees.stream()
.collect(Collectors.groupingBy(
Employee::department,
Collectors.maxBy(Comparator.comparingDouble(Employee::salary))
));
topEarner.forEach((dept, emp) ->
System.out.println(dept + " top: " + emp.map(Employee::name).orElse("N/A"))
);
}
}Output
Engineering: 2 employees
- Alice
- Charlie
Marketing: 1 employees
- Bob
Average salaries: {Engineering=77500.0, Marketing=60000.0}
Engineering top: Charlie
Marketing top: BobProgram 8: Implement Stack Using Queue
Example
import java.util.*;
public class StackUsingQueue<T> {
private Queue<T> queue = new LinkedList<>();
public void push(T item) {
queue.add(item);
// Rotate all previous elements to the back
for (int i = 0; i < queue.size() - 1; i++) {
queue.add(queue.poll());
}
}
public T pop() {
if (queue.isEmpty()) throw new EmptyStackException();
return queue.poll();
}
public T peek() {
if (queue.isEmpty()) throw new EmptyStackException();
return queue.peek();
}
public boolean isEmpty() {
return queue.isEmpty();
}
public static void main(String[] args) {
StackUsingQueue<Integer> stack = new StackUsingQueue<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop()); // 3
System.out.println(stack.pop()); // 2
System.out.println(stack.peek()); // 1
}
}
Output
3 2 1
Program 9: Find K Most Frequent Elements
Example
import java.util.*;
import java.util.stream.*;
public class TopKFrequent {
public static List<Integer> topKFrequent(int[] nums, int k) {
// Count frequencies
Map<Integer, Integer> freq = new HashMap<>();
for (int num : nums) {
freq.merge(num, 1, Integer::sum);
}
// Use PriorityQueue (min-heap of size k)
PriorityQueue<Map.Entry<Integer, Integer>> minHeap =
new PriorityQueue<>(Comparator.comparingInt(Map.Entry::getValue));
for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
minHeap.offer(entry);
if (minHeap.size() > k) {
minHeap.poll(); // Remove least frequent
}
}
List<Integer> result = new ArrayList<>();
while (!minHeap.isEmpty()) {
result.add(minHeap.poll().getKey());
}
Collections.reverse(result);
return result;
}
public static void main(String[] args) {
int[] nums = {1, 1, 1, 2, 2, 3, 3, 3, 3, 4};
System.out.println("Top 2 frequent: " + topKFrequent(nums, 2)); // [3, 1]
}
}
Output
Top 2 frequent: [3, 1]
Time Complexity: O(n log k) — n for counting, log k for heap operations.
Program 10: Custom Object in HashSet/HashMap
Problem: Demonstrate proper equals/hashCode implementation.
Example
import java.util.*;
public class Student {
private int id;
private String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public String toString() {
return "Student{id=" + id + ", name=" + name + "}";
}
public static void main(String[] args) {
Set<Student> students = new HashSet<>();
students.add(new Student(1, "Alice"));
students.add(new Student(2, "Bob"));
students.add(new Student(1, "Alice")); // Duplicate — won't be added
System.out.println("Size: " + students.size()); // 2
System.out.println("Contains Alice: " +
students.contains(new Student(1, "Alice"))); // true
// Without equals/hashCode override:
// Size would be 3 (all treated as different objects)
// Contains would return false
}
}
Output
Size: 2 Contains Alice: true
Program 11: Merge Two Sorted Lists
Example
import java.util.*;
public class MergeSortedLists {
public static <T extends Comparable<T>> List<T> merge(List<T> list1, List<T> list2) {
List<T> result = new ArrayList<>(list1.size() + list2.size());
int i = 0, j = 0;
while (i < list1.size() && j < list2.size()) {
if (list1.get(i).compareTo(list2.get(j)) <= 0) {
result.add(list1.get(i++));
} else {
result.add(list2.get(j++));
}
}
// Add remaining elements
while (i < list1.size()) result.add(list1.get(i++));
while (j < list2.size()) result.add(list2.get(j++));
return result;
}
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 3, 5, 7, 9);
List<Integer> list2 = Arrays.asList(2, 4, 6, 8, 10);
List<Integer> merged = merge(list1, list2);
System.out.println(merged); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}
Output
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Time Complexity: O(n + m) | Space: O(n + m)
Program 12: Producer-Consumer Using BlockingQueue
Example
import java.util.concurrent.*;
public class ProducerConsumer {
public static void main(String[] args) {
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
// Producer
Thread producer = new Thread(() -> {
try {
for (int i = 1; i <= 10; i++) {
queue.put(i); // Blocks if queue is full
System.out.println("Produced: " + i);
Thread.sleep(100);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
// Consumer
Thread consumer = new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
int value = queue.take(); // Blocks if queue is empty
System.out.println("Consumed: " + value);
Thread.sleep(200);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
producer.start();
consumer.start();
}
}
Output
Produced: 0 Produced: 1 Consumed: 0 Produced: 2 Consumed: 1 Produced: 3 Consumed: 2 Produced: 4 Consumed: 3 Consumed: 4
Program 13: Anagram Grouping
java example
import java.util.*;
import java.util.stream.*;
public class AnagramGrouping {
public static Map<String, List<String>> groupAnagrams(String[] words) {
return Arrays.stream(words)
.collect(Collectors.groupingBy(word -> {
char[] chars = word.toLowerCase().toCharArray();
Arrays.sort(chars);
return new String(chars);
}));
}
public static void main(String[] args) {
String[] words = {"eat", "tea", "tan", "ate", "nat", "bat"};
Map<String, List<String>> groups = groupAnagrams(words);
groups.forEach((key, anagrams) ->
System.out.println(anagrams));
}
}Output:
Example
[eat, tea, ate]
[tan, nat]
[bat]
Program 14: Flatten Nested Collections
Example
import java.util.*;
import java.util.stream.*;
public class FlattenCollections {
public static void main(String[] args) {
List<List<Integer>> nested = Arrays.asList(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5),
Arrays.asList(6, 7, 8, 9)
);
// Method 1: Stream flatMap
List<Integer> flat = nested.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList());
System.out.println(flat); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
// Method 2: Manual
List<Integer> flat2 = new ArrayList<>();
for (List<Integer> inner : nested) {
flat2.addAll(inner);
}
// Flatten Map<String, List<String>> to all values
Map<String, List<String>> map = Map.of(
"fruits", Arrays.asList("apple", "banana"),
"veggies", Arrays.asList("carrot", "pea")
);
List<String> allItems = map.values().stream()
.flatMap(Collection::stream)
.collect(Collectors.toList());
System.out.println(allItems); // [apple, banana, carrot, pea]
}
}
Output
[1, 2, 3, 4, 5, 6, 7, 8, 9] [apple, banana, carrot, pea]
Program 15: Immutable Collection Patterns
Example
import java.util.*;
public class ImmutableCollections {
public static void main(String[] args) {
// Java 9+ factory methods (truly immutable)
List<String> immutableList = List.of("A", "B", "C");
Set<String> immutableSet = Set.of("X", "Y", "Z");
Map<String, Integer> immutableMap = Map.of("one", 1, "two", 2);
// Pre-Java 9: Collections.unmodifiableXxx()
List<String> mutable = new ArrayList<>(Arrays.asList("A", "B", "C"));
List<String> unmodifiable = Collections.unmodifiableList(mutable);
// DANGER: The original list can still be modified!
mutable.add("D");
System.out.println(unmodifiable); // [A, B, C, D] — view changed!
// Safe: wrap a copy
List<String> safeUnmodifiable = Collections.unmodifiableList(
new ArrayList<>(mutable)
);
// Java 10+: List.copyOf() creates true unmodifiable copy
List<String> copy = List.copyOf(mutable);
try {
immutableList.add("D");
} catch (UnsupportedOperationException e) {
System.out.println("Cannot modify immutable list!");
}
}
}
Output
Unmodifiable view: [A, B, C] After modifying original... Unmodifiable view: [A, B, C, D] Cannot modify immutable list!
Summary: Which Collection for Which Problem?
| Problem | Best Collection | Why |
|---|---|---|
| Remove duplicates | LinkedHashSet | O(1) contains + preserves order |
| Frequency counting | HashMap | O(1) get/put |
| Top K elements | PriorityQueue | O(n log k) |
| LRU Cache | LinkedHashMap (access-order) | O(1) + auto-eviction |
| Sorted unique elements | TreeSet | O(log n) + sorted iteration |
| FIFO processing | ArrayDeque | O(1) offer/poll |
| Thread-safe queue | ConcurrentLinkedQueue or BlockingQueue | Lock-free or blocking |
| Group by property | HashMap<Key, List<Value>> | O(1) bucket access |
| Bidirectional lookup | Two HashMaps | O(1) both directions |
Interview Questions
Q1: How do you remove duplicates from an ArrayList?
A: Convert to a LinkedHashSet (preserves order) or HashSet (no order guarantee): new ArrayList<>(new LinkedHashSet<>(list)). Alternatively, use Java 8 streams: list.stream().distinct().collect(Collectors.toList()).
Q2: How do you find the frequency of each element in a collection?
A: Use Collections.frequency(collection, element) for a single element, or build a frequency map: map.merge(element, 1, Integer::sum) in a loop, or use streams with Collectors.groupingBy(Function.identity(), Collectors.counting()).
Q3: How do you sort a Map by its values?
A: Convert entries to a list and sort: entries.sort(Map.Entry.comparingByValue()). Or use streams: map.entrySet().stream().sorted(Map.Entry.comparingByValue()).collect(...).
Q4: What is the difference between Collections.unmodifiableList() and List.of()?
A: unmodifiableList() creates a read-only VIEW of the original list — changes to the original reflect through the view. List.of() (Java 9+) creates a truly IMMUTABLE list — no connection to any mutable source.
Q5: How do you implement an LRU Cache using collections?
A: Use LinkedHashMap with access-order enabled (constructor parameter true) and override removeEldestEntry() to return true when size exceeds capacity.
Q6: What is the most efficient way to find the intersection of two sets?
A: Use retainAll(): create a copy of set1, then call copy.retainAll(set2). Time complexity is O(n) for HashSets.
Q7: How do you merge two sorted lists efficiently?
A: Use a merge algorithm (like merge sort's merge step) with two pointers, comparing elements and adding the smaller one. Time complexity: O(n + m).
Q8: How do you find the top K frequent elements in a collection?
A: Build a frequency map, then use a PriorityQueue (min-heap of size K) or sort the entries by frequency and take the top K. Stream approach: group, sort by count descending, limit K.
Q9: How do you make an ArrayList thread-safe?
A: Three options: (1) Collections.synchronizedList(new ArrayList<>()), (2) Use CopyOnWriteArrayList for read-heavy scenarios, (3) External synchronization with explicit locks.
Q10: How do you flatten a list of lists into a single list?
A: Use flatMap with streams: listOfLists.stream().flatMap(Collection::stream).collect(Collectors.toList()). Or iteratively: loop through each inner list and addAll to result.
Q11: How do you implement a Stack using Queues?
A: Use two queues. For push: add to queue1. For pop: transfer all but last element from queue1 to queue2, remove last element, swap queues. This makes push O(1) and pop O(n), or vice versa.
Q12: What is the Producer-Consumer pattern with collections?
A: Use a BlockingQueue (like ArrayBlockingQueue) — producers call put() (blocks if full) and consumers call take() (blocks if empty). The queue handles all synchronization internally.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Collections Practice Programs.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, collections, framework, programs
Related Java Master Course Topics
Continue learning this concept
Collections FrameworkCollections Framework OverviewComplete guide to Java Collections Framework covering hierarchy, interfaces, implementations, algorithms, and choosing the right collection for your use case.Collections FrameworkComparable vs Comparator in JavaDeep dive into Comparable and Comparator interfaces in Java — natural ordering, custom sorting, lambda expressions, method references, and practical comparisons with examples.Collections FrameworkGenerics in JavaComplete guide to Java Generics — type parameters, bounded types, wildcards, type erasure, generic methods, generic classes, and common patterns with practical examples.Collections FrameworkIterator in JavaComplete guide to Iterator, ListIterator, and Iterable interfaces in Java — internal working, fail-fast behavior, custom iterators, and enhanced for-each loop mechanics.Collections FrameworkArrayList in JavaLearn ArrayList in Java from the ground up with clear explanations, practical examples, internal working, performance analysis, common pitfalls, and interview-focused insights designed for students and developers.Collections FrameworkLinkedList in JavaComplete guide to Java LinkedList — internal working with doubly-linked nodes, performance analysis, Deque operations, comparison with ArrayList, and when to use LinkedList.