The Java Collections Framework is a set of classes and interfaces that provide a structured way to store, manipulate, and process data efficiently. It includes List, Set, Map, and Queue interfaces, along with implementations like ArrayList, HashSet, HashMap, and PriorityQueue.

It provides reusable data structures to manage large amounts of data efficiently. Java Collections enhance performance by offering optimized algorithms for sorting, searching, and manipulating objects. The framework follows a consistent API and supports generics, concurrent operations, and fail-fast iterators, making it essential in Java interview preparation for handling real-world applications.

• Collection (Interface) – A root interface in the Java Collections Framework that defines methods for handling grouped objects, such as add(), remove(), and size(). It is extended by List, Set, and Queue.

• Collections (Class) – A utility class in java.util that provides static methods for sorting, searching, and modifying collections, such as sort(), reverse(), and synchronizedList().

• List – An ordered collection that allows duplicate elements (e.g., ArrayList, LinkedList).

• Set – A unique collection that does not allow duplicates (e.g., HashSet, TreeSet).

• Map – Stores key-value pairs, ensuring unique keys (e.g., HashMap, TreeMap).

• HashMap – Unordered, allows one null key.

• LinkedHashMap – Maintains insertion order.

• TreeMap – Sorted by keys (natural order or comparator).

• ConcurrentHashMap – Thread-safe for high concurrency.

• HashMap is non-synchronized, making it faster but not thread-safe. It allows one null key and multiple null values.

• Hashtable is synchronized, making it thread-safe but slower. It does not allow null keys or null values.

• HashSet stores unique elements in an unordered manner and provides O(1) insertion/search.

• TreeSet maintains sorted order and provides O(log n) insertion/search due to Red-Black Tree implementation.

• Fail-fast: Immediately throws ConcurrentModificationException if a collection is modified while iterating. Examples include ArrayList, HashMap.

• Fail-safe: Works on a cloned copy, allowing modifications without exceptions. Examples include ConcurrentHashMap, CopyOnWriteArrayList.

• Comparable: This interface is used when an object has a natural ordering. It contains the compareTo() method, which is implemented in the class itself. When using Comparable, only one sorting logic can be defined, and it modifies the original class. Example: The String class implements Comparable to sort words alphabetically.

• Comparator: Unlike Comparable, the Comparator interface allows defining multiple sorting strategies. It contains the compare() method, which is implemented externally rather than modifying the actual class. Using Comparator, we can create different comparison strategies for the same object, such as sorting employees by name, salary, or age.

• Stack follows the LIFO (Last In, First Out) principle, meaning the last element added is the first to be removed. It is implemented using the Stack<E> class in Java. A stack is commonly used in recursion, undo/redo functionality, and expression evaluation (e.g., parsing mathematical expressions).

• Queue follows the FIFO (First In, First Out) principle, meaning the first element added is the first to be removed. Queues are implemented using LinkedList<E>, PriorityQueue<E>, and ArrayDeque<E>. It is widely used in task scheduling, CPU process scheduling, and message queues.

• By default, a PriorityQueue in Java stores elements in ascending order (min-heap), but we can define a custom comparator to create a max-heap (highest priority first).

• Unlike a normal queue that follows FIFO, a PriorityQueue gives higher priority elements precedence over others, regardless of their insertion order.

1. Thread-Safety:
   • HashMap requires explicit synchronization when used in a multithreaded environment.
   • ConcurrentHashMap uses internal segmentation to allow concurrent modifications.
2. Performance:
   • HashMap performs better in single-threaded applications.
   • ConcurrentHashMap is optimized for multithreading scenarios by locking only parts of the data structure.

1. Ordering:
   • HashSet does not maintain order.
   • TreeSet maintains ascending order based on natural sorting or a custom comparator.
2. Performance:
   • HashSet offers O(1) lookup time using hashing.
   • TreeSet offers O(log n) lookup time due to its Red-Black Tree implementation.

• Fail-fast iterators immediately throw ConcurrentModificationException if a collection is structurally modified while iterating.

• They operate directly on the collection's internal structure, meaning any modification invalidates the iterator.

• Examples include iterators of ArrayList, HashSet, and HashMap.

• Fail-safe iterators do not throw exceptions when modifications occur during iteration.

• They operate on a copy of the collection, meaning changes do not affect the iteration process.

• Examples include iterators of ConcurrentHashMap and CopyOnWriteArrayList.

• It is useful for caching mechanisms where keys should be removed automatically when they are no longer in use.

• Unlike HashMap, WeakHashMap does not prevent its keys from being garbage collected.

• If a key is only referenced inside the WeakHashMap, it may be removed at any time by the garbage collector.

• Sorting: Collections.sort(list) sorts a list based on natural ordering or a custom comparator.

• Searching: Collections.binarySearch(list, key) finds elements in a sorted list.

• Synchronization: Collections.synchronizedList(list) creates a thread-safe version of a list.

• Min/Max Operations: Collections.min(list) and Collections.max(list) return the smallest and largest elements.

• Traversal Direction: Iterator allows only forward traversal, whereas ListIterator supports both forward and backward traversal.

• Modification Operations: ListIterator allows modification (add, remove, set) during iteration, while Iterator only supports removal.

• Applicable Collections: Iterator works with all collection types, whereas ListIterator is specific to lists (ArrayList, LinkedList).

• Queue follows FIFO (First-In-First-Out) ordering, while Deque supports both FIFO and LIFO (Last-In-First-Out) operations.

• Deque provides methods like addFirst(), addLast(), removeFirst(), and removeLast(), making it more flexible than Queue.

• Implementations include ArrayDeque (better performance than LinkedList) and LinkedList.

• LinkedHashSet extends HashSet and uses a linked list to track insertion order.

• HashSet relies on hashing, so elements are stored in an unpredictable order.

• LinkedHashSet is slightly slower than HashSet due to extra memory usage for maintaining order.

• In HashMap, keys are compared using .equals(), meaning two different objects with the same content are considered equal.

• In IdentityHashMap, only the exact same object reference is considered equal, even if two objects have identical data.

• IdentityHashMap is mainly used in serialization, object identity tracking, and performance testing.

• Unlike ArrayList, which requires manual synchronization for multi-threading, CopyOnWriteArrayList avoids concurrency issues without external locks.

• It is efficient for read-heavy operations since reads are lock-free, but writes are expensive due to array copying.

• Used in scenarios where reads significantly outnumber writes, such as caching, event listeners, and configuration settings.

• It enables operations like lower(), floor(), ceiling(), and higher(), which return elements closest to a given value.

• The default implementation, TreeSet, maintains elements in sorted order while supporting logarithmic time complexity for queries.

• It is useful for range-based queries, auto-suggestions, and scheduling applications.

• EnumSet only works with enum values, whereas HashSet and TreeSet can store any objects.

• It is not synchronized, so it requires external synchronization in multithreading scenarios.

• EnumSet is implemented as a bit vector, meaning it is faster and uses less memory compared to HashSet.

• Unlike Queue, BlockingQueue methods wait if the queue is full (on insertion) or empty (on retrieval).

• Common implementations include ArrayBlockingQueue, LinkedBlockingQueue, and PriorityBlockingQueue, each with different performance characteristics.

• BlockingQueue is used in producer-consumer problems, task scheduling, and thread pooling to manage concurrent data sharing safely.

• Unlike TreeMap, which uses a Red-Black tree, ConcurrentSkipListMap enables concurrent read and write operations without locking the entire structure.

• It is more scalable in highly concurrent environments as it provides non-blocking operations.

• ConcurrentSkipListMap is useful in applications needing sorted data with efficient concurrent access, such as stock price tracking or leaderboard ranking systems.