Advanced Java

1. What happens when this code runs?

static void pollute(List list) {
    list.add("oops");
}

public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        pollute(numbers);
        for (Integer n : numbers) {
            System.out.println(n);
        }
    }
}

It prints 1 then "oops" with no error.

It throws ClassCastException immediately inside pollute(...).

It prints 1, then throws ClassCastException on the second element.

It fails to compile -- pollute(list) cannot accept a List<Integer> argument.

2. Which statement correctly describes what a `Stream<T>` actually is?

A single-use pipeline that processes elements from a source in sequence -- it doesn't store data itself.

A data structure, similar to a List, that stores its elements internally.

A reusable pipeline that can be traversed multiple times via separate terminal operations.

A synchronized wrapper around a Collection for thread-safe access.

3. How many interfaces can a single class implement at once?

As many as it likes, separated by commas -- unlike extends, which is limited to one class.

Exactly one, the same limit as extends.

At most two.

Only if every interface involved is a functional interface.

4. Why can a broad `catch (Exception e)` block that does nothing meaningful be dangerous?

It prevents the program from compiling.

It automatically rethrows the exception after logging it.

It silently swallows every checked and unchecked exception, making debugging nearly impossible.

It also swallows every Error, since Exception includes Error.

5. What does this print?

public class Demo {
    static void check(int index) {
        int[] data = {1, 2, 3};
        try {
            System.out.println(data[index] / 0);
        } catch (RuntimeException e) {
            System.out.println("caught: " + e.getClass().getSimpleName());
        }
    }
    public static void main(String[] args) {
        check(1);
    }
}

Compile error: division by zero

The program crashes because ArithmeticException isn't a RuntimeException

caught: ArithmeticException

caught: ArrayIndexOutOfBoundsException

6. Which of the following are true about functional interfaces? (Select all that apply)

A functional interface has exactly one abstract method -- default and static methods don't count toward that number.

A lambda expression can be used directly as an instance of a functional interface.

Adding a second abstract method to a functional interface still lets existing lambda-based code compile unchanged.

The @FunctionalInterface annotation is required for an interface to be usable as a lambda target.

7. A `Map<String, Integer>` is declared, and code tries `map.put("Bob", "thirty")`, passing a String where an Integer value is expected. Which of the following are true? (Select all that apply)

The call fails to compile, since put(String, Integer) expects an Integer for the value.

Compile-time checking applies to every collection operation, not just construction.

The call compiles, and the mismatch would only surface later as a ClassCastException.

Map.put always accepts a plain Object for its value regardless of the declared type arguments.

8. What does this print?

import java.util.Comparator;
import java.util.function.BiFunction;

public class Demo {
    public static void main(String[] args) {
        Comparator<String> cmp = (a, b) -> a.length() - b.length();
        BiFunction<String, String, Integer> fn = (a, b) -> a.length() - b.length();
        System.out.println(cmp.compare("hi", "hello"));
        System.out.println(fn.apply("hi", "hello"));
    }
}

-3 -3

Compile error -- the same lambda can't implement two different interfaces.

-3 Compile error.

3 3

9. In `catch (IOException e) { ... }`, what is `e`?

A static field of the enclosing class.

An ordinary local variable scoped to that catch block, on which any Throwable method can be called.

A keyword with no type.

A reference that can only be used to print the exception's class name.

10. Which of the following correctly describe the three functions that make up a `Collector`? (Select all that apply)

A supplier creates an empty container to hold the result, like an empty ArrayList.

An accumulator adds each element into that container.

A combiner is only ever used for sequential streams, never for parallel ones.

Every static method in the Collectors class requires you to define all three functions yourself.

Test Your Knowledge