1Z0-829 Practice Test 37 — 15 Questions

Question 1

Given: HashSet set = new HashSet<>(); set.add("A"); set.add("B"); set.add("C"); set.add("A"); System.out.println(set.size()); What is the output?

Accepted Answer

3. HashSet does not allow duplicate elements. When adding "A" twice, the second add is ignored, so the set contains only three unique elements: "A", "B", and "C". Therefore, set.size() returns 3.

Answer

Compilation fails

Answer

4

Answer

2

Question 2

Which TWO statements are true about securing a Java application?

Accepted Answer

A security policy file can grant specific permissions to code from a particular codebase.. A Java security policy file can use a codebase URL (e.g., `codeBase "file:/path/to/jar"`) to grant specific permissions, such as `java.io.FilePermission`, to code loaded from that location. This is a core feature of the Java security model, allowing fine-grained access control based on where the code originates.

Answer

Enabling the security manager is required for all Java applications.

Answer

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

Answer

Using code signing guarantees that the application is secure.

Question 3

Which of the following correctly uses try-with-resources to ensure a FileInputStream is closed after use?

Accepted Answer

try (FileInputStream fis = new FileInputStream("file.txt")) { ... }. It uses the try-with-resources syntax (try (resource declaration) { ... }), which automatically closes the FileInputStream when the block exits, regardless of exceptions. This ensures the resource is closed without requiring an explicit finally block, as mandated by the AutoCloseable interface.

Answer

FileInputStream fis = new FileInputStream("file.txt"); try { ... } finally { fis.close(); }

Answer

try { FileInputStream fis = new FileInputStream("file.txt"); ... } finally { fis.close(); }

Answer

try (fis = new FileInputStream("file.txt")) { ... }

Question 4

Arrange the steps to override equals() and hashCode() correctly in Java.

Accepted Answer

Override equals() with @Override, check identity (==), check null/class, cast, compare fields, override hashCode() with @Override, use Objects.hash() with same fields. equals() and hashCode() must be consistent: if two objects are equal, they must have the same hash code. Use Objects.hash() for hashCode().

Answer

Override hashCode() with @Override and Objects.hash(), then override equals() with @Override, check identity, cast, compare fields (skip type/null check)

Answer

Override equals() with @Override, check identity, cast directly compare fields, override hashCode() with @Override using random values

Answer

Override equals() with @Override, check identity, check type, override hashCode() with @Override and Objects.hash(), then cast and compare fields

Question 5

Match each Java collection class to its underlying data structure.

Accepted Answer

ArrayList: Resizable array. ArrayList uses a resizable array; LinkedList uses a doubly linked list; HashSet uses a hash table; TreeSet uses a red-black tree. Common confusions involve mixing up TreeMap with ArrayList or HashMap with TreeMap.

Answer

HashMap: Red-black tree

Answer

TreeMap: Resizable array

Question 6

Arrange the steps to use a lambda expression to sort a list of strings by length.

Accepted Answer

Start by creating a list of strings. Then write a lambda expression that uses Integer.compare to compare string lengths. Then pass the lambda to the Collections.sort method. Finally, print the sorted list.. Comparator is a functional interface; lambda provides concise implementation. Integer.compare() handles comparison safely.

Answer

Start by writing a lambda expression that uses Integer.compare to compare string lengths. Then create a list of strings. Then pass the lambda to the Collections.sort method. Finally, print the sorted list.

Answer

Start by creating a list of strings. Then pass the lambda to the Collections.sort method. Then write a lambda expression that uses Integer.compare to compare string lengths. Finally, print the sorted list.

Answer

Start by creating a list of strings. Then write a lambda expression that uses Integer.compare to compare string lengths. Then print the sorted list. Finally, pass the lambda to the Collections.sort method.

Question 7

Match each Java keyword to its primary purpose.

Accepted Answer

volatile: Ensures that a variable's value is always read from main memory, preventing thread caching.. The correct matches are volatile for visibility, transient for serialization exclusion, and synchronized for locking. Common mistakes include confusing volatile with transient and transient with thread safety.

Answer

volatile: Prevents a field from being serialized.

Answer

transient: Ensures thread safety for a variable.

Question 8

A team needs to process a large collection of orders to calculate total revenue per region. They decide to use parallel streams to improve performance. Which statement about using parallel streams for this task is true?

Accepted Answer

Using a parallel stream with a stateful lambda operation can lead to incorrect results.. Parallel streams split the workload across multiple threads, and if the lambda operation is stateful (e.g., modifying a shared variable like a counter or a non-thread-safe collection), it can cause race conditions and produce incorrect results. The Streams API documentation explicitly warns against using stateful lambdas with parallel streams to avoid data integrity issues.

Answer

The stream() method returns a parallel stream by default.

Answer

Parallel streams always provide better performance than sequential streams.

Answer

Parallel streams cannot be used with custom thread pools.

Question 9

A Java developer is writing a batch processing application that reads records from a database and processes them. The processing must continue even if some records cause exceptions (e.g., data conversion errors). However, the application must log each failed record and its error, then continue with the next record. The developer uses a for loop to iterate over a list of records. Inside the loop, a try-catch block wraps the processing logic. After implementing, the developer notices that when an exception occurs, the loop terminates prematurely instead of continuing. The code structure is:

List<Record> records = fetchRecords();
for (Record rec : records) {
    try {
        process(rec);
    } catch (Exception e) {
        log.error("Failed to process: " + rec.getId(), e);
    }
}

What is the most likely reason for the premature termination?

Accepted Answer

The process() method throws an Error instead of an Exception.. The code catches `Exception`, but `Error` (and its subclasses like `OutOfMemoryError`, `StackOverflowError`, or custom `Error` types) are not subclasses of `Exception`. In Java, `Throwable` has two main branches: `Exception` (including `RuntimeException`) and `Error`. Since `Error` is not caught by `catch (Exception e)`, it propagates up and terminates the loop. This is the most likely reason for premature termination because the developer assumed all failures would be `Exception` types.

Answer

The records list contains null elements, causing a NullPointerException that is not caught.

Answer

The log.error() method itself throws an unchecked exception that is not caught.

Answer

The try-catch block is incorrectly placed inside the for loop, causing the loop to break on any exception.

Question 10

Which three of the following statements about the switch expression in Java 17 are correct?

Accepted Answer

A switch expression with arrow syntax does not require break.. In a switch expression with arrow syntax (->), each branch is a single expression or block that is automatically terminated, eliminating the need for a break statement. The arrow syntax implicitly prevents fall-through, making the code more concise and less error-prone.

Answer

A switch expression cannot be used with an enum type.

Answer

A switch expression must include a default branch even if all cases are covered.

Question 11

Consider the following code:

public void process() throws Exception {
    try {
        riskyMethod();
    } catch (IOException | SQLException e) {
        throw e;
    }
}

Assuming riskyMethod() declares both IOException and SQLException, what is the result?

Accepted Answer

The code compiles and runs correctly.. In Java 7+, multi-catch variables are implicitly final, so they can be rethrown without a cast. The compiler knows that the thrown exception is exactly one of the caught types (IOException or SQLException), and since both are checked exceptions declared in the method signature, the code compiles and runs correctly. Option D is correct.

Answer

Compilation fails because you cannot rethrow a multi-catch variable.

Answer

Compilation fails because the catch variable must be cast to Exception.

Answer

The code compiles, but throws a ClassCastException at runtime.

Question 12

You are developing a microservice that processes order payments. The service uses a custom exception hierarchy: PaymentException (checked), InsufficientFundsException (unchecked, extends RuntimeException), and NetworkException (checked, extends PaymentException). The processPayment method is declared as: public void processPayment(Order order) throws PaymentException. Inside, a call to an external payment gateway may throw InsufficientFundsException or NetworkException. The requirement is to log all payment failures to an audit system, but the service must continue processing other orders. The audit logging method is: public void logFailure(String message) throws Exception. Which approach best handles exceptions while meeting the requirements?

Accepted Answer

Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing.. It ensures that both checked (NetworkException) and unchecked (InsufficientFundsException) exceptions are caught locally, allowing the service to log the failure via logFailure (which itself throws Exception) without propagating the exception up the call stack. By catching any exception from logFailure and falling back to a generic logger, the method guarantees that processPayment returns normally, meeting the requirement to continue processing other orders. This approach respects the checked exception contract of processPayment (throws PaymentException) while handling all failure scenarios internally.

Answer

Wrap the call to the payment gateway in a try-catch-finally block. In the catch block, log the error using logFailure. In the finally block, return from the method.

Answer

Add a throws clause to processPayment for InsufficientFundsException and NetworkException, and let the caller handle them.

Answer

Catch InsufficientFundsException and NetworkException separately, log the error using logFailure, and then throw a new RuntimeException to indicate failure.

Question 13

Arrange the steps to read a file using NIO.2 Files.lines() in Java.

Accepted Answer

1. Create a Path object using Paths.get("file.txt"). 2. Call Files.lines(path) to obtain a Stream<String>. 3. Process the stream using stream operations like forEach, filter, etc. 4. Close the stream by calling close() or using try-with-resources.. Files.lines() returns a Stream that must be closed to release file handles. The stream is lazily populated.

Answer

1. Call Files.lines("file.txt") directly with a string. 2. Create a Path object. 3. Process the stream. 4. Close the stream.

Answer

1. Create a Path object. 2. Process the stream (e.g., apply operations). 3. Call Files.lines(path) to get the stream. 4. Close the stream.

Answer

1. Create a Path object. 2. Call Files.lines(path) to get the stream. 3. Close the stream. 4. Process the stream.

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

[two, three]. The code uses `dropWhile` on a stream of strings, which drops elements from the stream as long as the predicate (string length < 5) is true. Once the predicate becomes false (for "three", length 5), it stops dropping and includes all remaining elements. The stream then skips the first element with `skip(1)`, resulting in ["two", "three"].

Answer

[one, two, three, four]

Answer

[two]

Answer

[one, four]

Question 15

A financial trading application processes real-time stock data from multiple exchanges. The application reads large binary files (each up to 500 MB) containing trade records, processes them, and writes summary reports to a shared network drive. The development team observes that the application occasionally throws a java.io.IOException: 'The process cannot access the file because it is being used by another process' when writing reports. The application is multi-threaded, and each thread writes to a separate file in the same directory. The team also notices that the application slows down significantly when the network drive is under heavy load. The application runs on Windows servers with Java 17. The code uses FileOutputStream for writing and does not explicitly close streams in some paths. Which course of action should the team take to resolve the issues and improve performance?

Accepted Answer

Switch to using try-with-resources for all FileOutputStream instances and wrap them in BufferedOutputStream with a larger buffer.. The primary issue is resource leaks from not closing FileOutputStream instances, which can cause file locking conflicts on Windows when multiple threads write to separate files in the same directory. Using try-with-resources ensures streams are closed reliably, eliminating the 'file in use' IOException. Wrapping with BufferedOutputStream and a larger buffer reduces the number of write operations to the network drive, mitigating slowdowns under heavy load by batching data and minimizing latency.

Answer

Increase the thread pool size to handle more concurrent writes.

Answer

Use FileChannel with FileLock to synchronize access.

Answer

Write to local temporary files and then copy to the network drive.