Select Two (Multi-Select) Questions

Case values can be runtime expressions.

Why wrong: Case values must be compile-time constants.

A break statement is mandatory after each case block.

Why wrong: Break is optional; fall-through occurs without it.

Case labels can be variables if they are final and assigned a constant expression.

Why wrong: They must be compile-time constants, but final variables are allowed only if initialized with constant expressions.

The Collection.forEach() method is inherited from the Collection interface.

Why wrong: It is inherited from Iterable.

The Collection interface inherits the stream() method from the Iterable interface.

Why wrong: stream() is defined in Collection, not Iterable.

ArithmeticException

Why wrong: ArithmeticException is an unchecked exception.

ArrayIndexOutOfBoundsException

Why wrong: ArrayIndexOutOfBoundsException is an unchecked exception.

NullPointerException

Why wrong: NullPointerException is an unchecked exception.

The module path is searched after the class path when resolving types.

Why wrong: The module path and class path are separate; the class path is used for unnamed module and the module path for named modules.

An automatic module is one that has a module-info.class file at its root.

Why wrong: An automatic module is created from a JAR placed on the module path without a module-info.class.

A named module can access the unnamed module without any explicit declaration.

Why wrong: Named modules are not allowed to read the unnamed module unless the --add-reads flag is used.

ZIP file containing compiled classes

Why wrong: ZIP is not a standard Java packaging format.

Shell script that compiles and runs the application

Why wrong: That is not a packaging format.

Better performance for all I/O operations compared to java.io.

Why wrong: Performance gains vary; not all operations are faster.

Automatic file compression when writing.

Why wrong: Compression is not built-in; it requires additional libraries.

java.io.Console can be used to read from and write to the standard streams of the JVM.

Why wrong: Console is for interacting with the system console, not general streams.

java.io.FileInputStream supports the mark and reset methods.

Why wrong: FileInputStream does not support mark/reset; BufferedInputStream does.

java.nio.file.Path is a class that represents a file path.

Why wrong: Path is an interface, not a class.

Parallel streams always improve performance over sequential streams.

Why wrong: Performance depends on data size and operation complexity.

Any lambda expression is safe to use in a parallel stream.

Why wrong: Lambdas must be stateless and non-interfering.

Using parallel streams guarantees the order of elements in the result.

Why wrong: Order is not guaranteed unless using forEachOrdered.

The Boolean constructor is the preferred way to create a Boolean object.

Why wrong: Boolean constructor is deprecated; valueOf is preferred.

Boolean has three possible values: true, false, and null.

Why wrong: Boolean is an object wrapper; it can be null, but the boolean primitive has only two values.

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.

The resource variable must be declared as final.

Why wrong: It is effectively final, but explicit final is optional.

A try-with-resources statement cannot have a finally block.

Why wrong: It can have a finally block.

Resources are closed before the try block executes.

Why wrong: They are closed after the try block completes.

It allows null elements.

Why wrong: Null not allowed.

It orders elements based on insertion order.

Why wrong: Orders by priority, not insertion.

It provides O(1) time for contains().

Why wrong: O(n) for contains.

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

Why wrong: Only one abstract method.

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

Why wrong: Lambdas are for interfaces only.

a, b -> a + b

Why wrong: Parentheses required for multiple parameters.

(a, b) -> { a + b; }

Why wrong: Block lambda must have return statement if not void.

(int a, b) -> a + b

Why wrong: Cannot mix explicit and implicit types.

The collect() method is an intermediate operation.

Why wrong: It is a terminal operation.

A stream can be traversed multiple times.

Why wrong: Streams can only be consumed once.

The map() method returns a stream of the same type.

Why wrong: It can return a different type.

Enabling the security manager is required for all Java applications.

Why wrong: Security manager is optional; many applications run without it.

The Java Cryptography Extension (JCE) is deprecated and should not be used.

Why wrong: JCE is still part of Java SE and not deprecated.

Using code signing guarantees that the application is secure.

Why wrong: Code signing verifies origin but does not enforce security policy.

String content = new FileReader("file.txt").readString();

Why wrong: FileReader does not have readString() method.

String content = Files.readAllLines(Path.of("file.txt"));

Why wrong: readAllLines returns List<String>, not String.

The serialVersionUID must be explicitly declared in every serializable class.

Why wrong: If not declared, Java computes one automatically.

A class that implements Externalizable does not need to implement Serializable.

Why wrong: Externalizable extends Serializable.

Fields marked as transient are serialized by default.

Why wrong: Transient fields are excluded from serialization.

A sealed interface cannot use the permits clause.

Why wrong: Sealed interfaces can use permits.

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

Why wrong: If the subclasses are in the same source file, the permits clause can be omitted.

A sealed class must be declared as abstract.

Why wrong: Sealed classes can be concrete or abstract.

A switch statement can be used as an expression in all cases.

Why wrong: Switch expressions (with ->) can assign a value, but traditional switch with colon cannot.

The switch expression can be of type long.

Why wrong: long is not allowed; switch supports byte, short, char, int, String, and enum types.

The case values can be variables.

Why wrong: Case values must be compile-time constants (literals or final variables initialized with constants).