Oracle Certified Professional Java SE 17 Developer 1Z0-829 (1Z0-829) — Questions 451–513

Why this answer

How to eliminate wrong answers

Option A is wrong because removing parallelism is unnecessary; the core issue is the thread-unsafe map supplier, not parallelism itself. Option B is wrong because the merge function `(t1, t2) -> t1.merge(t2)` is associative (merging is order-independent) and not the cause of missing entries. Option C is wrong because using `forEach` with `ConcurrentHashMap` and `putIfAbsent` would work but is a manual, less idiomatic approach; the correct fix is to simply supply a thread-safe map to the collector, which is simpler and preserves the parallel stream's performance benefits.

Why this answer

How to eliminate wrong answers

Option A is wrong because `java.base` is just one specific module, not the list of all modules; `--list-modules` shows all platform modules, not just those in `java.base`. Option B is wrong because the command does not depend on any application; it lists all modules in the JDK, not only those required by the current application. Option D is wrong because `--list-modules` shows available modules, not currently loaded modules; modules are loaded lazily by the JVM at runtime, and this command does not trigger loading.

Why this answer

How to eliminate wrong answers

Option B is wrong because it assumes that after printing 'Two', the switch exits without falling through to case 'Three', but without a break statement, fall-through occurs. Option C is wrong because it includes 'Default' in the output, but the default case is only executed if no matching case is found; here, case 2 matches, so default is skipped. Option D is wrong because it suggests that case 'One' also executes, but the switch starts matching from the value 2, so case 'One' is never entered.

Why this answer

Why this order

Why this answer

How to eliminate wrong answers

Option A is wrong because a break statement after processing a combination would exit the inner loop entirely, not skip rows conditionally; the issue is about skipping too many iterations, not missing a break. Option C is wrong because the condition `prices1[i] < prices2[j]` is correctly evaluated; the bug is in the control flow, not the condition logic. Option D is wrong because `break outer` would exit the outer loop entirely, terminating all processing, which is not the intended behavior of skipping a row.

Why this answer

How to eliminate wrong answers

Option A is wrong because converting all modules to unnamed modules by removing module-info files would defeat the purpose of modularization, breaking encapsulation and potentially causing classpath conflicts; it does not fix the missing 'requires' directive. Option C is wrong because placing the Jackson jar on the classpath instead of the module path would make it an unnamed module, which would still not grant 'com.bank.core' read access to Jackson's packages unless the module reads the unnamed module (via 'requires java.base' or '--add-reads'), and it would also lose the benefits of reliable configuration. Option D is wrong because using jlink to create a custom runtime image does not resolve the missing module readability; jlink only includes modules that are explicitly required, and if 'com.bank.core' does not require Jackson, the error persists.

Why this answer

How to eliminate wrong answers

Option A is wrong because ISO week date (e.g., '2023-W01-1') is a calendar system that defines weeks and days, not a source of parsing errors related to a 60th second. Option B is wrong because time zone offsets (e.g., +05:30) represent fixed differences from UTC and do not introduce an extra second in the minute. Option C is wrong because Daylight Saving Time involves shifting clocks forward or backward by one hour, not inserting or removing a single second.

Why this answer

How to eliminate wrong answers

Option B is wrong because TreeSet never replaces an existing element; it simply refuses to add a duplicate when compareTo() returns 0. Option C is wrong because no ClassCastException occurs unless the objects are not mutually comparable (e.g., different types without a shared Comparable implementation), which is not the case here. Option D is wrong because TreeSet does not preserve insertion order; it maintains elements in sorted order according to the Comparable/Comparator, and duplicates are not added at all.

Why this answer

How to eliminate wrong answers

Option A is wrong because LinkedList provides O(n) random access by index (traversing from head/tail), while ArrayList offers O(1) index-based access via its array backing. Option B is wrong because fast iteration over all elements is equally efficient for both (O(n)), but ArrayList has better cache locality and lower overhead per element, making it generally faster for iteration. Option C is wrong because LinkedList has higher memory overhead due to storing node objects with forward and backward pointers (typically 24+ bytes per element), whereas ArrayList stores elements in a compact contiguous array with minimal overhead.

Why this answer

How to eliminate wrong answers

Option A is wrong because parallelism does not prevent peek from printing; it would still print, though possibly interleaved. Option C is wrong because peek cannot be placed after a terminal operation; terminal operations end the pipeline, so any operation after them would cause a compilation error. Option D is wrong because an empty stream would still cause peek to execute (it would simply not print anything), but the question states no output is printed, implying the pipeline never ran.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option B is wrong because `String.format` with `%t` conversion specifiers expects a `Date` or `Calendar` object, not a `LocalDateTime`; it will cause a runtime `IllegalFormatConversionException`. Option C is wrong because `SimpleDateFormat` works with `java.util.Date`, not `java.time.LocalDateTime`, and using it would require conversion and is not type-safe; it also represents the legacy API that is error-prone and non-thread-safe. Option D is wrong because `DateTimeFormatter.ISO_LOCAL_DATE_TIME` produces the ISO-8601 format like '2025-03-15T14:30:00', not the custom pattern 'dd/MM/yyyy HH:mm:ss'.

Why this answer

Why this answer

Why these pairings

Why these pairings

Why this answer

How to eliminate wrong answers

Option A is wrong because the stream is consumed by the first `forEach`, so the second `forEach` never executes, and `abc` is printed only once, not as the final result. Option B is wrong because `NullPointerException` would only occur if the stream source or an element were null, but here the stream is valid and the elements are non-null strings. Option D is wrong because `abcabc` would require the stream to be traversed twice, which is impossible since a stream cannot be reused after a terminal operation.

Why this answer

How to eliminate wrong answers

Option B is wrong because `sorted().limit(1).findFirst()` still requires sorting all elements before limiting, so it does not improve performance over the original. Option C is wrong because `parallel().sorted().findFirst()` adds parallelism overhead and still sorts all elements, and `findFirst()` is a short-circuiting operation that may not benefit from parallelism due to ordering constraints. Option D is wrong because `sorted().collect(Collectors.toList()).get(0)` materializes the entire sorted list into memory before retrieving the first element, which is even less efficient than the original pipeline.

Why this answer

How to eliminate wrong answers

Option B is wrong because the code compiles and runs correctly; there is no requirement for i to be declared final in a while loop. Option C is wrong because it omits the final value 1, but the loop prints i before decrementing, so when i = 1, it prints 1, then i becomes 0 and the loop exits. Option D is wrong because it starts at 4 instead of 5, but the initial value of i is 5, and the first iteration prints 5.

Why this answer

How to eliminate wrong answers

Option A is wrong because `Files.readAllLines(path)` reads the entire file into a `List<String>` in memory, which would cause an `OutOfMemoryError` for a file over 2 GB. Option B is wrong because `FileOutputStream` is designed for binary byte output, not reading text; using its `read()` method would require manual byte-to-character conversion and lacks line-by-line parsing, making it inefficient and error-prone for text files. Option C is wrong because `Scanner` with `hasNextLine()` internally buffers the file and can be slower for large files due to its regex-based tokenization overhead, and it does not leverage the optimized lazy streaming of `Files.lines()`.

Why this answer

How to eliminate wrong answers

Option A is wrong because it assumes the loop completes all five iterations (0 through 4) without considering the `break` statement, leading to a count of 4 instead of 3. Option C is wrong because it incorrectly counts the iteration where `i == 3` as executing the increment, but `break` exits before `count++` runs for that iteration, so the count is 3, not 5. Option D is wrong because there is no compilation error; the code is syntactically valid with proper loop syntax and a `break` statement inside an `if`.

Why this answer

How to eliminate wrong answers

Option B is wrong because the -s (summary) flag does not suppress module names; it merely shortens the output to show only module-level dependencies without package details, so a resolved dependency would still show its module name. Option C is wrong because a missing or corrupt JAR file would cause jdeps to fail with an error message, not produce a 'notfound' entry in the dependency output. Option D is wrong because cyclic dependencies among modules are reported differently by jdeps (e.g., with a cycle warning), not as 'notfound'.

Why this answer

How to eliminate wrong answers

Option A is wrong because `jdeps` output shows dependencies at the package level, not the class level; it would report a dependency on the package `com.thirdparty.util`, not on a specific class. Option B is wrong because whether a dependency is modular or not does not affect whether it is required; if `app.jar` uses types from `com.thirdparty.helper`, it must have a direct or transitive dependency on that module, regardless of its modular status. Option C is wrong because `jdeps` does not indicate whether dependencies are on the module path; it only reports the dependencies found, not their location (module path vs. class path).

Why this answer

How to eliminate wrong answers

Option A is wrong because using a for loop with index and `list.remove(index)` while decrementing the index can still cause issues if not carefully managed (e.g., shifting elements), and it is error-prone and less efficient than the dedicated removal methods. Option B is wrong because while `Iterator.remove()` is safe and avoids ConcurrentModificationException, it is more verbose and not the 'best' approach compared to `removeIf()`, which is simpler and more expressive. Option C is wrong because using a for-each loop with `list.remove()` directly modifies the list during iteration, which throws ConcurrentModificationException as the for-each loop uses an internal iterator that detects concurrent modification.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because overriding readResolve() to return null does not prevent deserialization; readResolve() is called after the object is already deserialized, and returning null simply replaces the deserialized object with null, but the object has already been created in memory. Option C is wrong because overriding writeObject() to encrypt the object only affects serialization, not deserialization; the attacker can still call readObject() on the encrypted stream if they have the decryption key or bypass the encryption entirely. Option D is wrong because overriding writeReplace() to throw an exception only prevents serialization (writing), not deserialization; the developer wants to prevent deserialization, and writeReplace() is invoked during serialization, not during reading.

Why this answer

How to eliminate wrong answers

Option A is wrong because Files.readAllLines() loads the entire file into memory as a List<String>, which would require at least 500 MB (plus overhead for String objects and UTF-16 encoding) and likely cause an OutOfMemoryError with a 512 MB heap. Option C is wrong because memory-mapping the entire file with a FileChannel would still map the full 500 MB into virtual memory, consuming significant heap or native memory and risking memory pressure; it also does not inherently offload CPU-bound processing to a separate thread. Option D is wrong because a WatchService is designed for monitoring file system changes (e.g., modifications, deletions) and has no role in reading or processing file contents; it would not help with reading or processing the CSV rows.

Why this answer

How to eliminate wrong answers

Option B is wrong because classes in java.nio.file are not thread-safe by default; while some operations may be atomic, the API does not guarantee thread safety for all methods, and concurrent access requires external synchronization. Option C is wrong because the Path interface is part of the java.nio.file package, not java.io; java.io contains File, which is a legacy class. Option D is wrong because java.nio.file is not deprecated; it is the modern replacement for java.io, offering improved performance and features, and java.io itself is not deprecated but is considered legacy for many use cases.

Why this answer

How to eliminate wrong answers

Option A is wrong because `new ArrayList<>(Arrays.asList(array))` creates a mutable, modifiable list, not an immutable one, and also incurs unnecessary copying overhead. Option B is wrong because `Collections.unmodifiableList(Arrays.asList(array))` returns a view that is unmodifiable but still backed by the original array, meaning changes to the array (if passed elsewhere) can affect the list, and it does not enforce null-hostility. Option C is wrong because `Arrays.asList(array)` returns a fixed-size list backed by the original array, which is mutable (via `set`), not immutable, and allows null elements.

Why this answer

How to eliminate wrong answers

Option A is wrong because `Files.copy(source, target, StandardCopyOption.COPY_ATTRIBUTES)` on a directory only copies the directory entry itself, not its contents; it does not recursively copy the tree. Option C is wrong because `Files.walk()` returns a `Stream<Path>` that does not inherently handle directory creation or attribute preservation during copy; using `Files.copy` on each entry without a `FileVisitor` would fail to create parent directories and could overwrite or skip files incorrectly. Option D is wrong because `FileUtils.copyDirectory` from Apache Commons IO is a third-party library method, not part of the standard Java I/O API, and the question asks for a method within the standard Java API.

Why this answer

How to eliminate wrong answers

Option B is wrong because using try-catch for each line introduces exception-handling overhead, which is inefficient for millions of entries and violates the requirement to avoid try-catch per line. Option C is wrong because `DateTimeFormatter.ofPattern` does not support union patterns; the syntax shown is invalid and would cause a compile-time or runtime error. Option D is wrong because `SimpleDateFormat` is not thread-safe, and synchronizing the method would create a performance bottleneck, defeating the thread-safety and efficiency requirements.

Why this answer

How to eliminate wrong answers

Option A is wrong because ConcurrentHashMap does not allow null keys or null values, as its design for concurrent access requires non-null keys to avoid ambiguity in synchronization. Option B is wrong because TreeMap does not permit null keys (though it allows null values), as it relies on natural ordering or a Comparator that would throw a NullPointerException when comparing null. Option D is wrong because Hashtable is a legacy synchronized class that does not allow null keys or null values, throwing a NullPointerException if attempted.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because it omits the file permissions granted under `/data/`, which include both read and write access. Option C is wrong because it incorrectly restricts file access to read-only, while the policy explicitly grants `read,write`. Option D is wrong because it ignores the socket permission that allows connecting to any socket.

Why this answer

How to eliminate wrong answers

Option A is wrong because the `--illegal-access=permit` flag was a Java 9–16 transitional option that allowed access to internal APIs; in Java 17, this flag is no longer supported and defaults to `deny`, so setting it to `permit` would not change the behavior. Option C is wrong because the module path not including the library would cause a `ModuleNotFoundException` or `ClassNotFoundException`, not an `IllegalAccessError`; the error here is about access control, not missing modules. Option D is wrong because the library not being in a named module (i.e., being on the classpath) actually makes it more likely to be subject to strong encapsulation, but the error is not about module naming; the core issue is that `sun.misc.Unsafe` is an internal API that is encapsulated regardless of whether the library is named or unnamed.

Why this answer

How to eliminate wrong answers

Option A is wrong because the switch does not fall through to the default; the String case matches exactly, so "Unknown" is never assigned. Option B is wrong because the code compiles successfully; Java 17+ supports pattern matching for switch with type patterns, and the switch expression is complete with a default branch. Option D is wrong because obj is not an Integer; it is a String, so the Integer case does not match.

Why this answer

How to eliminate wrong answers

Option A is wrong because a corrupted serialized object typically causes a `StreamCorruptedException` or `EOFException`, not an `InvalidClassException`. Option B is wrong because incompatible JVM versions may cause class loading issues or `UnsupportedClassVersionError`, but the `InvalidClassException` is specifically about mismatched `serialVersionUID` values, not JVM version incompatibility. Option C is wrong because if the file contains data that is not a serialized object, the deserialization attempt would throw a `StreamCorruptedException` or `ClassNotFoundException`, not an `InvalidClassException`.

Why this answer

How to eliminate wrong answers

Option A is wrong because adding a multi-catch block for SubException1 and SubException2 would require modifying the catch signatures, which violates the requirement that client methods must continue to compile without modifying their catch signatures. Option B is wrong because modifying the client method signature to declare throws SubException1, SubException2 would change the method contract and require all callers to handle these exceptions, which is unnecessary and violates the requirement to keep client methods unchanged. Option C is wrong because adding separate catch blocks for SubException1 and SubException2 before the existing BaseException catch would modify the catch structure, which is not allowed per the requirement; the existing BaseException catch already handles all subclasses, making additional catch blocks redundant and a violation of the 'no modification' constraint.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because `ThreadLocalRandom` is optimized for concurrent access but uses a non-cryptographic PRNG (based on a linear congruential generator) and is not suitable for secure key generation. Option B is wrong because `Math.random()` internally uses `Random` and produces predictable sequences that can be reverse-engineered, making it insecure for cryptographic use. Option C is wrong because `Random` uses a 48-bit seed with a linear congruential formula, which is deterministic and predictable if the seed is known, failing to meet cryptographic randomness requirements.

Why this answer

How to eliminate wrong answers

Option A is wrong because each thread having its own copy of the file handle does not prevent resource leaks; it merely avoids shared state issues, but the handles still need to be closed properly. Option C is wrong because calling close() on each stream in a separate try-catch block is error-prone and verbose; it does not guarantee closure if an exception occurs before reaching the close() call, and it can lead to suppressed exceptions being lost. Option D is wrong because FileLock is used for coordinating access to a file across processes, not for preventing resource leaks; it does not handle the automatic closing of file handles.

Why this answer

How to eliminate wrong answers

Option B is wrong because it is actually correct, but the question requires selecting both B and C, so B alone is incomplete. Option C is wrong because it is also correct, but again incomplete on its own. Option D is wrong because `Collectors.groupingBy` by default produces a `HashMap` (or a mutable `Map`), not a `ConcurrentMap`; to get a `ConcurrentMap`, you must use `groupingByConcurrent` or supply a `ConcurrentMap` factory via the overloaded `groupingBy` method.

Why this answer

How to eliminate wrong answers

Option A is wrong because it assumes only the matching case executes, ignoring fall-through behavior in switch statements without break. Option B is wrong because it incorrectly includes case 4, but the break in case 3 prevents fall-through to case 4. Option D is wrong because it assumes the default case executes first, but default only runs if no matching case is found; here case 2 matches, so default is skipped.

Why this answer

How to eliminate wrong answers

Option A is wrong because `Files.lines()` returns a `Stream<String>` that must be collected (e.g., via `collect(Collectors.toList())`) to get a list, but the question asks for reading 'all lines' and the option as written is syntactically incomplete (missing semicolon) and not the most direct NIO.2 method for this task. Option B is wrong because `Files.readString()` reads the entire file content as a single `String`, not as a list of lines, so it does not meet the requirement to read 'all lines'. Option C is wrong because `Files.readAllBytes()` returns a `byte[]`, and calling `.toString()` on a byte array returns a meaningless representation like `[B@hashcode`, not the file content as lines.

Why this answer

How to eliminate wrong answers

Option A is wrong because the boolean expression is syntactically valid; Java allows mixing `&&` and `||` in a single expression. Option C is wrong because all variables are initialized with literal values, so the output is deterministic at compile time. Option D is wrong because it assumes the expression evaluates to true, which would only happen if `c` were true or both `a` and `b` were true.

Why this answer

How to eliminate wrong answers

Option A is wrong because it uses a regular string literal with an explicit escape sequence (\n) for a newline, not a text block. Option C is wrong because single quotes (') are used for character literals in Java, not strings, and the syntax is invalid for a multi-line string. Option D is wrong because it uses the text block delimiter (""") but includes an explicit \n escape sequence inside the block, which is unnecessary and defeats the purpose of a text block; text blocks automatically handle line breaks.

Why this answer

How to eliminate wrong answers

Option A is wrong because "HelloWorld" would only appear if Sub's print() called super.print() before printing "World", but the exhibit (per the answer) shows Sub's print() does not call super.print(), so only "World" is output. Option C is wrong because "Hello" would be output only if Sub's print() called super.print() without printing anything else, but Sub's print() prints "World" after the super call (or instead of it). Option D is wrong because there is no compilation error; the code compiles successfully as Sub extends Super and overrides print() with a valid method signature.

Why this answer

How to eliminate wrong answers

Option B (Count: 3) is wrong because it assumes the list has three non-'A' elements, but the correct count is 2, meaning the list either has only two non-'A' elements or includes a distinct() operation that reduces duplicates. Option C (Count: 1) is wrong because it underestimates the number of non-'A' elements; the filter does not remove all elements, only those equal to 'A'. Option D (Count: 4) is wrong because it ignores the filter entirely, counting all elements including 'A's, which is not what the stream does.

Why this answer

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because the loop condition i<5 is true when i=0, so the loop body executes at least once, not zero times. Option B is wrong because the loop stops when i reaches 5, so it executes 5 times, not 6; a sixth iteration would require i<5 to be true when i=5, which it is not. Option D is wrong because the loop executes for i=0 through i=4 inclusive, which is 5 iterations, not 4; the increment happens after each print, so i=4 is the last value printed.

Why this answer

How to eliminate wrong answers

Option B is wrong because the `Inner` class does not need to be static to access the outer class's private field; a non-static inner class has implicit access to the outer class's private members. Option C is wrong because `x` being private does not cause a compilation error; private members are accessible within the same top-level class, and the inner class is part of the outer class. Option D is wrong because `x` is initialized to 10 in the `Outer` constructor before `printX()` is called, so it is not uninitialized.

Why this answer

How to eliminate wrong answers

Option A is wrong because `Files.copy(Path, Path)` is a high-level method that reads the source file into a buffer and writes it to the destination, involving multiple kernel-to-user-space copies, which is less efficient than zero-copy. Option B is wrong because `RandomAccessFile.getChannel().write(ByteBuffer)` requires manually managing a `ByteBuffer` and performing a read-then-write cycle, which adds overhead and does not leverage OS-level zero-copy optimization. Option C is wrong because `InputStream.transferTo(OutputStream)` operates at the stream level, reading bytes into an internal buffer and writing them out, which involves multiple data copies and is not channel-based, thus lacking the direct kernel-to-kernel transfer capability.

Why this answer

How to eliminate wrong answers

Option A is wrong because the code compiles successfully; Java 14+ switch expressions allow 'case null' as a valid label. Option B is wrong because no NullPointerException is thrown; the 'case null' explicitly handles the null reference. Option C is wrong because the default branch is not reached; the switch matches the 'case null' branch first.

Why this answer

How to eliminate wrong answers

Option A is wrong because an empty catch block swallows the exception, preventing it from propagating, which violates the requirement that the exception not be swallowed. Option B is wrong because while a catch block that rethrows the exception preserves the exception, the finally block still executes, but the catch block itself is unnecessary for the requirement and adds complexity; the question asks for a construct that ensures execution without swallowing, and try-finally alone suffices. Option D is wrong because try-with-resources without a catch will close resources automatically but does not include a finally block; if an exception occurs, the resource closing mechanism may suppress exceptions (via suppressed exceptions), potentially swallowing the primary exception, and there is no guarantee of unconditional code execution after the try block.

Why this answer

How to eliminate wrong answers

Option B is wrong because it uses i <= arr.length, which still causes an ArrayIndexOutOfBoundsException when i equals arr.length (since valid indices are 0 to arr.length-1). Option C is wrong because i <= arr.length-1 is functionally equivalent to i < arr.length, but the question asks which change 'fixes' the exception; while this would also work, it is not the listed correct answer and introduces unnecessary complexity. Option D is wrong because changing the print statement to arr[i-1] would cause an ArrayIndexOutOfBoundsException on the first iteration when i=0 (accessing arr[-1]), and does not fix the root cause of the loop bounds.

Why this answer

How to eliminate wrong answers

Option A is wrong because it states the leap second is ignored entirely, but the API actually adds a nanosecond to represent the leap second, not discarding it. Option C is wrong because the parser does not throw a DateTimeParseException; it accepts the '60' seconds value as a valid leap second representation. Option D is wrong because the string is valid ISO-8601 format and does not cause a null return; Instant.parse() always returns a non-null Instant or throws an exception.

Why this answer

How to eliminate wrong answers

Option A is wrong because improved rethrow analysis applies only when the caught exception parameter is effectively final and the method declares the specific exception types; here, methodA does not declare Exception, so the compiler cannot infer that IOException is the only exception thrown. Option B is wrong because the code does not compile, so it cannot print 'Caught in main: Exception'. Option D is wrong because the code does not compile, so it cannot print 'Caught in main: IOException'.