`Collectors.toList()` is the correct collector for gathering stream elements into a `List`. While `toList()` was added as a convenience method in Java 16, the 1Z0-819 exam focuses on Java 11, where `Collectors.toList()` is the standard approach. Option C would only work with a static import, which isn’t shown. Option D is not valid stream API syntax.

`HashMap` is not synchronized. In a multi-threaded environment like a web application handling multiple user sessions, concurrent modifications (via `put`) can corrupt its internal structure, leading to exceptions, infinite loops, or lost data. While option D suggests a fix, the core issue stated in option B is the root cause. The class should use a concurrent collection like `ConcurrentHashMap`.

A key principle of the Java Platform Module System (JPMS) is strong encapsulation. A module only grants access to the packages it explicitly exports. Even if `com.app.client` has a `requires com.app.utils;` directive, it can only access public types in the `com.app.utils.stringproc` package. The `com.app.utils.mathops` package is effectively hidden.

The try-with-resources statement can manage multiple resources declared in the parentheses, separated by semicolons (as in A). It can also manage a single resource that wraps another (as in B). In both cases, the `close()` method is called automatically on all resources that implement `AutoCloseable`. Closing the `BufferedReader` will also close the underlying `FileReader` it wraps.

All three methods are valid and safe for iterating over a `Properties` object (which extends `Hashtable`). `stringPropertyNames()` returns a `Set` of keys for properties that are strings. `entrySet()` returns a `Set>`. The `forEach` method (available since Java 8) accepts a `BiConsumer`. None of these will cause a `ConcurrentModificationException` during a simple read-only iteration.

The `Files.move(source, target)` method, when the target is an existing directory, will only succeed if the source is a directory and the target directory is empty. Here, the source is a file (`Q1.pdf`). The operation will fail with a `FileAlreadyExistsException` because the target path (`/data/archive`) already exists and is not being used as a container for the source file. To move the file *into* the directory, the target should be `Paths.get(“/data/archive/Q1.pdf”)` or use `target.resolve(source.getFileName())`.

`Optional.of(value)` requires a non-null `value`. If you pass `null`, it immediately throws a `NullPointerException`. Since `Map.get(key)` can return `null`, this code is buggy. The correct API to use when the value might be `null` is `Optional.ofNullable(value)`. This is a fundamental distinction in using `Optional` correctly.

Instance methods in Java use dynamic (late) binding. The actual method that is executed depends on the runtime type of the object (`FileLogger`), not the reference type (`Logger`). Both calls use the same underlying `FileLogger` object, so the overridden `FileLogger.log` method is invoked in both cases. The cast in the second line does not change the object’s type, only the compiler’s perception of it.

`scheduleWithFixedDelay` is designed for this scenario. It creates a sequence of tasks where each subsequent execution is scheduled only *after* the previous one has completed, with the specified delay (5 seconds) between the *end* of one and the *start* of the next. `scheduleAtFixedRate` (option A) would attempt to start a new task every 5 seconds regardless of whether the previous one finished, which could lead to overlapping executions or thread pool exhaustion.

`Collectors.toList()` is the correct collector for gathering stream elements into a `List`. While `toList()` was added as a convenience method in Java 16, the 1Z0-819 exam focuses on Java 11, where `Collectors.toList()` is the standard approach. Option C would only work with a static import, which isn’t shown. Option D is not valid stream API syntax.0