OCP Generics and Collections Questions and Answers

Question 1

Which of the following statements is true regarding the behavior of generics in Java at runtime?

Accepted Answer

Generic type information is discarded by the compiler through a process called type erasure.

Answer

Java uses a process called type erasure to implement generics. During compilation, the generic type information is removed, and all generic types are replaced by their raw types (usually `Object` or an upper bound). This ensures backward compatibility with older Java versions that do not support generics. Consequently, at runtime, the JVM has no knowledge of the specific type parameters like `String` or `Integer` for a `List`, treating them all as a raw `List`.

Question 2

A developer needs to create a list of strings that will not be modified after its creation. Which of the following is the most appropriate way to initialize this list in modern Java (9 and later)?

Accepted Answer

List<String> list = List.of("A", "B");

Answer

The `List.of()` factory method, introduced in Java 9, is the most concise and direct way to create an immutable list. The list it returns is unmodifiable, meaning any attempt to add, remove, or change elements will result in an `UnsupportedOperationException`. While `Collections.unmodifiableList` also creates an unmodifiable view, `List.of()` is preferred for its simplicity and efficiency for creating new, constant lists.

Question 3

What is the primary difference between the `Comparable` and `Comparator` interfaces in Java?

Accepted Answer

`Comparable` defines a single, natural ordering for a class, whereas `Comparator` allows for multiple, external sorting strategies.

Answer

The `Comparable` interface is intended to be implemented by a class to define its 'natural ordering' via the `compareTo()` method. This provides a single, default way to sort objects of that class. The `Comparator` interface, on the other hand, is implemented in a separate class to define custom or multiple sorting strategies. This allows objects to be sorted in different ways without modifying their source code.

Question 4

Examine the following code snippet: ```java NavigableSet set = new TreeSet<>(); set.add(10); set.add(20); set.add(30); set.add(40); System.out.println(set.lower(30)); System.out.println(set.floor(30)); System.out.println(set.higher(30)); ``` What will be the output?

Accepted Answer

20
30
40

Answer

The `NavigableSet` interface provides methods for finding elements relative to a given value. `lower(E e)` returns the greatest element strictly less than `e`. In this case, `set.lower(30)` returns 20. `floor(E e)` returns the greatest element less than or equal to `e`. So, `set.floor(30)` returns 30. `higher(E e)` returns the least element strictly greater than `e`, so `set.higher(30)` returns 40.

Question 5

Which generic wildcard should be used in a method signature `void process(List<?> list)` to allow the method to add `Integer` objects to the list?

Accepted Answer

List<? super Integer>

Answer

The `? super Integer` wildcard, known as a lower-bounded wildcard, restricts the unknown type to be a supertype of `Integer` (or `Integer` itself). This allows you to safely add `Integer` objects (or subtypes of `Integer`, though `Integer` is final) to the collection, as they will always be compatible with the list's actual type. An upper-bounded wildcard (`? extends T`) is for reading, and an unbounded wildcard (`?`) is also primarily for reading as the compiler cannot guarantee what type is safe to add.

(OCP) Oracle Certified Professional Practice Test

(OCP) Oracle Certified Professional Practice Test

OCP Generics and Collections Questions and Answers