📦Java Collections Programs

Adds and removes elements from both ends of an ArrayDeque.

Adds, reads, and replaces elements in an ArrayList by index.

Creates, modifies, and iterates over an ArrayList.

Converts an ArrayList into a plain array of the same type.

Walks through an ArrayList three ways: a for-each loop, an explicit Iterator, and an index-based loop.

Strips duplicate elements out of an ArrayList while keeping the original order.

Reverses the order of an ArrayList's elements in place.

Checks whether an ArrayList contains a value and finds its position.

Sorts an ArrayList of integers into ascending order.

Counts how many times one specific value appears in a List using Collections.frequency().

Finds the largest element in an unsorted list using Collections.max().

Finds the smallest element in an unsorted List using Collections.min().

Reverses the order of any List in place using Collections.reverse().

Finds an element's index in a sorted list using Collections.binarySearch().

Randomly reorders a List using Collections.shuffle(), with a fixed seed for reproducible output.

Swaps the elements at two given positions in a List using Collections.swap().

Implements Comparable on a custom class to define its natural ordering.

Converts a List into a Set by passing it straight into a HashSet constructor.

Pulls a Map's keys out into a standalone List.

Pulls every value out of a Map into a standalone List.

Converts a Set into a List by passing it straight into an ArrayList constructor.

Uses a HashMap to tally how many times each character shows up in a string.

Finds the elements shared between two Lists using retainAll().

Uses a HashMap to find every value that shows up more than once in an array.

Uses a HashMap to find the first character in a string whose total count is exactly one.

Stores key-value pairs in a HashMap and looks them up by key.

Walks through a HashMap's entries, keys, and values using entrySet(), keySet(), and values().

Adds elements to a HashSet and shows that duplicates are silently ignored.

Stores key-value pairs in a legacy, synchronized Hashtable.

Creates a genuinely immutable List using the List.of() factory method.

Creates a genuinely immutable Map using the Map.of() factory method.

Creates a genuinely immutable Set using the Set.of() factory method.

Walks a list with an explicit Iterator and removes matching elements safely during iteration.

Stores key-value pairs in a LinkedHashMap, which preserves insertion order.

Adds elements to a LinkedHashSet and shows they iterate back out in the same order they were added.

Builds up a LinkedList by inserting elements at both its front and back.

Adds, reads by index, and removes elements from a LinkedList.

Uses a LinkedList through the Queue interface for first-in-first-out processing.

Removes elements from both the front and back of a LinkedList.

Reverses the order of elements in a LinkedList.

Combines two Lists into a single List using addAll().

Uses the Queue interface's offer/poll/peek methods to process elements first-in-first-out.

Deduplicates a List by funneling it through a Set.

Strips every null entry out of a List using removeIf().

Sorts a List of custom objects using the natural ordering defined by Comparable.

Sorts a list of custom objects using an external Comparator instead of natural ordering.

Uses the legacy Stack class for last-in-first-out access.

Uses the legacy synchronized Vector class as a resizable list.

Wraps a mutable List in a read-only view using Collections.unmodifiableList(), and shows the view still reflects changes to the original.

Uses a HashMap to tally how many times each word shows up in a sentence.

Sorts a list of objects by one field, then breaks ties using a second field.

Uses a single Deque both as a stack and as a queue in the same program.

Triggers ConcurrentModificationException by modifying a list directly while a for-each loop is iterating it.

Takes an existing HashMap and produces its entries sorted by key, after the fact.

Takes an existing HashMap and produces its entries sorted by value instead of by key.

Traverses a list forward and backward, and replaces an element mid-traversal, using ListIterator.

Adds integers out of order and polls them back out in ascending order.

Produces a sorted list of a Set's elements, since a Set itself has no defined order.

Uses ArrayDeque's push/pop/peek methods to get stack behavior without the legacy Stack class.

Stores key-value pairs in a TreeMap, which keeps them sorted by key automatically.

Adds integers out of order to a TreeSet and iterates them back out sorted.

Counts how often each word appears in a sentence.

Finds whether a linked list loops back on itself, and where the loop begins, with Floyd's tortoise-and-hare algorithm.

Builds a binary search tree with insert, search, in-order traversal and height, using recursive node links.

Builds a small hash map from scratch with an array of buckets, collision chaining and automatic resizing.

Builds a fixed-size cache that evicts the least recently used entry, first with LinkedHashMap and then from scratch.

Finds the shortest route from one city to every other in a weighted graph using Dijkstra's algorithm and a priority queue.

Visits every node of a graph breadth-first with a queue and depth-first with recursion, using an adjacency list.