Advanced Java

1. Which statement correctly describes an interface's static method?

It belongs to no implementer, is called directly through the interface name, and can never be overridden.

It's inherited by every implementing class and can be overridden just like a default method.

It can only be called through an instance of an implementing class.

It's implicitly abstract and must be implemented by every implementing class.

2. What does this print?

List<String> names = new ArrayList<>();
names.add("Sam");
System.out.println(names.getClass().getSimpleName());

ArrayList

ArrayList<String>

List

Compile error -- the diamond operator requires an explicit type argument on the left.

3. Which of the following is identified as a common mistake in this lesson?

Assuming checked exceptions are always "better" or "more professional" than unchecked ones.

Using RuntimeException for a programming error.

Passing the original exception as cause when wrapping.

Declaring throws for a checked exception a method can genuinely throw.

4. Which of the following will fail to compile?

try {
    int[] arr = new int[2];
    System.out.println(arr[5]);
} catch (RuntimeException e) {
    System.out.println("runtime");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("array");
}

It compiles and prints "runtime".

It compiles and prints "array".

It fails to compile because the second catch block is unreachable.

It compiles but throws an uncaught exception at runtime.

5. Why can the exact same lambda expression `(a, b) -> a.length() - b.length()` be assigned to both `Comparator<String>` and `BiFunction<String, String, Integer>`?

Because the compiler automatically converts between any two functional interfaces.

Because lambdas are dynamically typed at runtime, so the target interface doesn't matter.

Because both interfaces' single abstract method has the exact same shape -- two Strings in, one Integer/int result out.

Because Comparator and BiFunction are actually the same interface under different names.

6. How does `Collectors.partitioningBy(predicate)` differ from `Collectors.groupingBy()` in terms of guaranteed map keys?

partitioningBy() always produces both a true and a false key, even if one group is empty; groupingBy() only includes keys that actually had matching elements.

groupingBy() always produces exactly two keys, just like partitioningBy().

partitioningBy() omits a key entirely if that group is empty, exactly like groupingBy().

Neither guarantees any particular set of keys in the result.

7. What does this print?

import java.util.function.BiFunction;
import java.util.function.Function;

public class Demo {
    public static void main(String[] args) {
        Function<String, Integer> parse = Integer::parseInt;
        BiFunction<String, String, Boolean> starts = String::startsWith;
        System.out.println(parse.apply("42"));
        System.out.println(starts.apply("hello", "he"));
    }
}

42 true

Compile error -- String::startsWith needs an existing String object to bind to.

42 false

Compile error -- BiFunction can't accept a method reference.

8. Why does extending `Throwable` directly (instead of `Exception` or `RuntimeException`) count as a common mistake?

It makes the exception automatically checked.

It prevents the exception from carrying a message.

Throwable cannot be extended at all.

It bypasses the checked/unchecked distinction entirely, and is almost never what you actually want.

9. Which of the following are true about `ArrayDeque` vs. `LinkedList` performance, according to this lesson? (Select all that apply)

LinkedList was measured faster than ArrayDeque in every single run of the lesson's benchmark.

ArrayDeque cannot be used as a Deque, only as a Queue.

Both are theoretically O(1) for the same Deque operations, but their constant factors differ.

LinkedList allocates a separate node object for every element, which ArrayDeque avoids.

10. Which of the following are true about iterating a `Map` when you need both the key and the value? (Select all that apply)

Iterating keySet() and calling get(key) at each step performs an unnecessary second lookup.

entrySet() gives both the key and value in a single step, with a single lookup.

keySet() + get() is always faster than entrySet() because keySet() is a smaller collection.

entrySet() cannot be used with a for-each loop.

Test Your Knowledge