Select Two (Multi-Select) Questions

A lambda expression can throw any checked exception.

Why wrong: False: Lambdas can only throw checked exceptions declared in the functional interface method, not any checked exception.

A lambda expression can be used to implement multiple abstract methods.

Why wrong: False: A lambda can only implement one abstract method, not multiple.

A lambda expression can be used to create an instance of an abstract class.

Why wrong: False: Lambdas cannot create instances of abstract classes; they work only with functional interfaces.

Optional.of(null) returns an empty Optional

Why wrong: Optional.of(null) throws NullPointerException; use ofNullable for null-safe.

Optional.get() on empty Optional returns null

Why wrong: get() throws NoSuchElementException if Optional is empty.

A while loop always executes at least once.

Why wrong: While loop may execute zero times.

A do-while loop may execute zero times if the condition is false.

Why wrong: Do-while executes at least once.

LocalDate.from(Instant.now())

Why wrong: Cannot derive LocalDate from Instant directly.

LocalDate.of(2023, 13, 1)

Why wrong: Month 13 is invalid.

LocalDate.ofEpochDay("19375")

Why wrong: ofEpochDay expects long, not String.

getHash()

Why wrong: No such method.

getValueOrDefault()

Why wrong: Not a method.

A sealed interface cannot use the permits clause.

Why wrong: This statement is false because a sealed interface can indeed use the `permits` clause to specify which classes can implement it.

The permits clause must list all direct subclasses of a sealed class.

Why wrong: This statement is false. The `permits` clause is not mandatory if the sealed class and its direct subclasses are declared in the same compilation unit. Additionally, even when used, it must list all permitted subclasses, but it is not always required.

A sealed class must be declared as abstract.

Why wrong: This statement is false. A sealed class can be concrete (non-abstract). For example, a sealed class can be instantiated.

Stream.of("a").collect(Collectors.toList())

Why wrong: Returns mutable list.

Arrays.asList("a", "b")

Why wrong: Returns fixed-size but mutable list.

new ArrayList<>()

Why wrong: Mutable list.

Duration.ofDays(1) returns a Duration that is daylight-saving-safe.

Why wrong: Duration is fixed 24 hours, not DST-aware.

Duration.between(LocalDate.now(), LocalDate.now().plusDays(1)) returns a Duration of 1 day.

Why wrong: Duration.between requires temporals that support seconds; LocalDate does not.

Duration can represent a period of months.

Why wrong: Period represents months, not Duration.

Define custom exceptions without providing any additional context.

Why wrong: Custom exceptions should include useful information.

Catch exceptions at the highest level of the application and log them generically.

Why wrong: Catching Exception broadly is discouraged; handle where possible.

ArithmeticException

Why wrong: ArithmeticException is an unchecked exception.

ArrayIndexOutOfBoundsException

Why wrong: ArrayIndexOutOfBoundsException is an unchecked exception.

NullPointerException

Why wrong: NullPointerException is an unchecked exception.

Comparator's compare method returns a boolean.

Why wrong: False: compare returns an int.

A class implementing Comparable must override equals().

Why wrong: False: Only compareTo is required; overriding equals is optional.

Comparator is in java.lang package.

Why wrong: False: Comparator is in java.util package.

substring(int, int, Locale)

Why wrong: Incorrect: No such overload; substring only takes start and end indices.

indent(String)

Why wrong: Incorrect: There is indent(int) but not indent(String).

new ArrayList<>(10, 20, 30)

Why wrong: No constructor takes varargs of elements; this is invalid syntax.

(ArrayList<Integer>) Arrays.asList(1,2,3)

Why wrong: Casting to ArrayList fails at runtime because Arrays.asList returns a java.util.Arrays.ArrayList (a private inner class) not java.util.ArrayList.

Duration supports units like months and years.

Why wrong: Incorrect: Duration only supports days, hours, minutes, seconds, and nanoseconds.

Duration.between(LocalDate.now(), LocalDate.now()) returns a Duration.

Why wrong: Incorrect: Duration.between requires temporals with seconds; use between LocalDateTimes.

Duration uses a days-based representation.

Why wrong: Incorrect: Duration uses seconds and nanoseconds; days are converted to seconds.

It supports adding and removing elements.

Why wrong: The list is fixed-size; add and remove throw UnsupportedOperationException.

It returns a new ArrayList with a copy of the elements.

Why wrong: It returns a List view, not a new ArrayList.

It can be used to convert an array to a mutable list if wrapped with new ArrayList<>().

Why wrong: This is a common usage, but it is not a property of Arrays.asList itself; the statement is about the method.

Arrays.asList("a", "b")

Why wrong: Returns fixed-size but mutable via set.

List.of(List.of("a", "b"))

Why wrong: Creates a list containing a list, not a flat immutable list.

new ArrayList<>(List.of("a", "b"))

Why wrong: Creates a mutable ArrayList.

System.setProperty("java.security.policy", "policy.url") loads a new policy.

Why wrong: Only sets the property; explicit Policy refresh needed.

By default, Java 17 applications run with a SecurityManager installed.

Why wrong: No default SecurityManager; must be enabled manually.

jpackage requires an existing JRE to create a runtime image.

Why wrong: jpackage needs a JDK, as it uses jlink internally.

jpackage uses the Java Packager library.

Why wrong: jpackage is a replacement for the deprecated Java Packager.

Case values can be runtime expressions.

Why wrong: Incorrect. Case values must be compile-time constant expressions.

A break statement is mandatory after each case block.

Why wrong: Incorrect. break is optional; without it, execution falls through to the next case.

An automatic module can access all packages of named modules without explicit requires.

Why wrong: Automatic modules can only access exported packages of named modules.

The unnamed module can read only the java.base module.

Why wrong: The unnamed module can read all named modules on the module path.

The unnamed module is a named module.

Why wrong: The unnamed module is not a named module; it's a special module for the classpath.