Java Programming - MCQ Practice Questions

CopyOnWriteArrayList maintains insertion order and is thread-safe. It creates a copy of the array on modification.

ListIterator extends Iterator and provides bidirectional traversal using previous() and next() methods.

TreeSet maintains sorted order (O(log n) insertion/deletion) using a Red-Black tree structure.

Iterator.next() throws NoSuchElementException when hasNext() returns false and next() is called.

lower() returns the greatest element < given element. floor() returns <= element.

Collections.frequency() correctly handles null values and returns the count of null elements in the collection.

Records (Java 14+) provide compact syntax for data carriers used with collections, improving performance and readability.

ConcurrentHashMap uses segment-based locking allowing safe iteration during concurrent modifications. HashMap throws ConcurrentModificationException.

subList() returns a view (structural reference) to the original list in O(1) time, not a copy.

forEachOrdered() preserves encounter order even in parallel streams, while forEach() doesn't guarantee order.

Collections.sort() uses TimSort (hybrid of merge and insertion sort) with O(n log n) worst-case, but QuickSort's worst-case is O(n²).

LinkedHashMap can be extended and removeEldestEntry() overridden to implement LRU cache eviction policy.

Spliterator provides split() capability enabling efficient parallel stream processing with characteristics advertisement.

Set interface explicitly does not allow duplicate elements. List allows duplicates, Queue is for ordered collections, and Map stores key-value pairs.

HashMap uses a hash table with buckets (arrays of linked lists or red-black trees) to store key-value pairs for efficient O(1) average lookup time.

LinkedHashSet maintains insertion order using a doubly-linked list. HashSet does not maintain order, TreeSet maintains sorted order, and ConcurrentHashMap doesn't guarantee insertion order.

TreeMap is based on Red-Black tree, so get(), put(), and remove() operations have O(log n) time complexity due to tree traversal.

Vector is a legacy synchronized collection, while ArrayList is unsynchronized but faster. For thread-safety with ArrayList, use Collections.synchronizedList().

peek() returns the head element without removing it. poll() removes and returns, remove() throws exception if empty, and pop() is not a PriorityQueue method.

TreeSet uses comparator or natural ordering, which cannot handle null values, throwing NullPointerException during insertion.