Collections Quiz - Languages Java

Free practice quiz: Collections (Languages Java). 51 multiple-choice questions with answers and explanations. Play online, no sign-up needed.

This Languages Java practice quiz has 51 multiple-choice questions on Collections, and 51 of them come with an explanation. Try the 5 sample questions below (tap an option to check yourself), then play the full quiz online. No sign-up needed.

Sample questions

1. Which of the following is an immutable List implementation in Java's Collections framework?

   1. ArrayList
   2. LinkedList
   3. CopyOnWriteArrayList
   4. UnmodifiableList
   Show answer

   Answer: D. UnmodifiableList

   UnmodifiableList is an interface that provides a view of a list that cannot be modified. While not a concrete class itself, implementations that wrap existing lists to make them unmodifiable (like `Collections.unmodifiableList(list)`) ensure immutability. ArrayList and LinkedList are mutable. CopyOnWriteArrayList provides thread-safe modification but is not immutable.

2. Which `Set` implementation does not permit duplicate elements and does not guarantee any specific order of elements?

   1. TreeSet
   2. LinkedHashSet
   3. HashSet
   4. EnumSet
   Show answer

   Answer: C. HashSet

   `HashSet` uses a hash table for storage. It does not allow duplicate elements and does not maintain any order of iteration. `TreeSet` maintains sorted order, `LinkedHashSet` maintains insertion order.

3. Consider the code: `List<String> list = Arrays.asList("a", "b", "c"); Iterator<String> it = list.iterator(); it.next(); it.remove(); System.out.println(list);`. What will be printed?

   1. [a, b, c]
   2. [b, c]
   3. [a, c]
   4. An exception will be thrown.
   Show answer

   Answer: B. [b, c]

   `Arrays.asList()` creates a fixed-size list backed by the array. The `iterator().remove()` method removes the element last returned by `next()`. So, after calling `it.next()`, "a" is the current element. Calling `it.remove()` removes "a" from the list. The list then contains ["b", "c"].

4. Which of the following is a `Map` interface implementation that uses a hash table and allows `null` keys and values?

   1. TreeMap
   2. Hashtable
   3. LinkedHashMap
   4. HashMap
   Show answer

   Answer: D. HashMap

   `HashMap` uses a hash table and allows one `null` key and multiple `null` values. `TreeMap` does not allow `null` keys (but allows `null` values if the `Comparator` handles them). `Hashtable` does not allow `null` keys or values. `LinkedHashMap` also allows one `null` key and multiple `null` values.

5. What is the Big O notation for iterating through all elements of a `TreeSet` of size 'n'?

   1. O(1)
   2. O(log n)
   3. O(n)
   4. O(n log n)
   Show answer

   Answer: C. O(n)

   Iterating through a `TreeSet` involves traversing the underlying balanced binary search tree. Since the tree contains 'n' elements, and visiting each element once takes constant time per node, the total time complexity for iteration is O(n).

More questions in this quiz

Answers and explanations are in the full quiz.

1. What is the primary difference between `HashSet` and `TreeSet` in terms of element storage and retrieval?
2. When would you choose a `LinkedHashMap` over a `HashMap`?
3. Which interface in Java Collections represents a collection that is guaranteed to be sorted according to natural ordering or by a `Comparator`?
4. What is the time complexity for iterating through all elements of an `ArrayList` of size 'n'?
5. Which of the following is a thread-safe implementation of a `List` in Java?
6. What exception is typically thrown when attempting to remove an element from an empty `Iterator` using its `remove()` method?
7. Consider the following code: `Map<String, Integer> map = new HashMap<>(); map.put("apple", 1); map.put("banana", 2); map.put("apple", 3); System.out.println(map.get("apple"));`. What will be printed?
8. Which of the following `Queue` implementations is suitable for implementing a priority queue?
9. What is the effect of calling `Collections.sort()` on a `List` containing `null` elements?
10. What is the purpose of the `ListIterator` interface?
11. Which of the following is true about `ArrayDeque`?
12. What is the Big O notation for adding an element to the end of an `ArrayList` when the underlying array needs to be resized?
13. Which method is used to retrieve and remove the head of a `Queue` without throwing an exception if the queue is empty?
14. What is the primary advantage of using `EnumSet` over `HashSet` for storing enum constants?
15. Which of the following `Map` implementations is suitable for maintaining the insertion order of keys?
16. What is the difference between `Collections.sort(list)` and `list.sort(null)` in Java 8 and later?
17. What is the primary characteristic of a `PriorityQueue` concerning its elements?
18. Which method on a `Map` returns a `Set` view of the values contained in the map?
19. What is the primary use case for `ConcurrentHashMap`?
20. Which interface represents a collection that holds elements with a natural ordering or a specified `Comparator` and does not allow duplicate elements?
21. What is the Big O notation for getting an element at a specific index 'i' from an `ArrayList`?
22. Which of the following collections does NOT allow `null` elements?
23. What is the main difference between `HashMap` and `TreeMap` in terms of key ordering?
24. Which method should be used to retrieve and remove the head of a `Queue` if an exception is desired when the queue is empty?
25. What is the Big O notation for adding an element to the beginning of a `LinkedList`?
26. Which `Set` implementation maintains elements in the order they were inserted?
27. What is the purpose of the `Collections.unmodifiableList()` method?
28. What is the Big O notation for removing an element from the middle of an `ArrayList`?
29. Which of the following is a synchronized `Map` implementation?
30. What is the time complexity for removing an element from the beginning of a `LinkedList`?
31. Which method returns an immutable `List` from a `Map`'s key set?
32. What is the primary purpose of the `Deque` interface?
33. If you need to sort a `List` of custom objects using a specific criterion not present in their natural ordering, which approach would you use?
34. What is the Big O notation for checking if an element exists in a `HashSet`?
35. Which `Map` implementation provides sorted keys and thread-safe access?
36. What is the purpose of the `Queue` interface in Java Collections?
37. Which of the following is a thread-safe, non-blocking `Queue` implementation?
38. What exception is thrown by `Collections.sort()` if the list contains elements that are not mutually comparable (e.g., mixing `String` and `Integer` without a custom `Comparator`)?
39. Which `Map` interface method returns a `Set` of `Map.Entry` objects, allowing access to both keys and values?
40. What is the Big O notation for adding an element to the end of a `LinkedList`?
41. Which of the following is a disadvantage of using `Vector` compared to `ArrayList`?
42. What happens when you call `add()` on an `Iterator` obtained from an `ArrayList`?
43. Which `Collection` interface provides a method to efficiently add elements at both ends?
44. What is the Big O notation for checking if an element exists in a `TreeSet`?
45. Which `Map` implementation is guaranteed to provide its entries in ascending order of keys?
46. What is the result of calling `collections.reverseOrder()`?

More quizzes

• JVM Internals▶ Play
• Memory Management▶ Play
• Syntax▶ Play
• Threads and Concurrency▶ Play
• Web Applications▶ Play

Browse all Java quizzes

More to play