1Z0-829 Practice Test 3 — 25 Questions

Question 1

A Java application reads configuration from a file using FileInputStream. The application must handle the case where the configuration file is missing by logging a warning and using default values. Which design approach best meets this requirement?

Accepted Answer

Use Files.exists() to check file existence before opening the stream, and if absent, log a warning and use defaults.. Option B is correct because it explicitly checks for file existence using `Files.exists()` before attempting to open the stream, allowing the application to log a warning and fall back to default values without throwing an exception. This approach aligns with the requirement to handle a missing configuration file gracefully, avoiding unnecessary exception handling overhead. The `Files.exists()` method is part of the modern `java.nio.file` API, which is preferred over the legacy `File.exists()` for its better integration with symbolic links and file system operations.

Answer

Wrap the FileInputStream in a try-with-resources and catch Exception to handle missing file.

Answer

Catch FileNotFoundException inside the try block and set default values.

Answer

Use File.exists() to check file existence before opening the stream, and if absent, log a warning and use defaults.

Question 2

A team is developing a large enterprise application using Java 17. The application consists of multiple modules: core (provides logging and configuration), services (business logic), and web (REST endpoints). The modules are packaged as separate JAR files and deployed on a server. During runtime, the web module throws a java.lang.ClassNotFoundException for a class that is part of the core module. The core module's module-info.java exports the package containing the missing class. The web module's module-info.java requires core. However, the services module also needs the same class but uses a different version of it, causing conflicts. The team decides to use the class path for the conflicting package and the module path for the rest. They add the conflicting JAR to the class path and keep the other JARs on the module path. After this change, the web module still cannot find the class, but the services module works fine. What is the most likely cause of the issue?

Accepted Answer

The web module is a named module and cannot access classes from a split package that is also in the unnamed module.. Option C is correct because when a named module (the web module) is on the module path, it cannot access classes from the unnamed module (the class path) if those classes belong to a package that is also exported by another named module on the module path. This creates a split package, which is forbidden by the Java module system. The core module exports the package, so the web module cannot load the class from the class path JAR, resulting in ClassNotFoundException.

Answer

The services module is using an automatic module, which automatically reads the unnamed module, while the web module is a named module that does not.

Answer

The class path is not scanned for JAR files unless the module path is empty.

Answer

The core module's module-info.java does not export the package to the web module; it only exports it to all modules.

Question 3

Which TWO statements are true about the sealed class feature in Java 17?

Accepted Answer

A sealed class restricts which other classes or interfaces may extend or implement it.. Option A is correct because the primary purpose of the sealed class feature is to explicitly control which other classes or interfaces are permitted to extend or implement it. This is achieved by using the `permits` clause to list the allowed subclasses, thereby restricting the inheritance hierarchy.

Answer

A sealed interface cannot use the permits clause.

Answer

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

Answer

A sealed class must be declared as abstract.

Question 4

A developer needs to filter a list of transactions where the amount is greater than 100 and collect the results into a new list. Which approach is best practice for readability and performance?

Accepted Answer

transactions.stream().filter(t -> t.getAmount() > 100).collect(Collectors.toList()). Option A is correct because it uses the Stream API's `filter` method to declaratively select transactions with an amount greater than 100, and `collect(Collectors.toList())` to gather results into a new list. This approach is both readable and performant, leveraging lazy evaluation and internal iteration for efficient processing.

Answer

List result = new ArrayList<>(); for(Transaction t : transactions) { if(t.getAmount() > 100) result.add(t); }

Answer

transactions.stream().filter(t -> t.getAmount() > 100).toArray()

Answer

transactions.removeIf(t -> t.getAmount() <= 100)

Question 5

Which TWO statements about the switch statement in Java are true?

Accepted Answer

A break statement is optional.. Option A is correct because in a Java switch statement, the break statement is optional. If omitted, execution falls through to the next case (fall-through behavior), which can be intentional or lead to bugs. This is a core feature of the switch construct, not a requirement.

Answer

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

Answer

The switch expression can be of type long.

Answer

The case values can be variables.

Question 6

What is the output when the code is executed?

Accepted Answer

Arithmetic
Finally
[stack trace]. Option D is correct because the code throws an ArithmeticException (division by zero) inside the try block, which is caught by the first catch block (ArithmeticException). The finally block always executes after the catch block, printing 'Finally'. The stack trace is printed because the exception is re-thrown in the catch block (implicitly or explicitly) and not handled, causing the program to terminate with an uncaught exception. The output shows 'Arithmetic', then 'Finally', followed by the stack trace.

Answer

Arithmetic
Finally

Answer

Arithmetic
Exception
Finally

Answer

Exception
Finally

Question 7

Which TWO statements about the try-with-resources statement are true? (Choose two.)

Accepted Answer

Resources declared in the try-with-resources block are closed automatically.. Option C is correct because the try-with-resources statement automatically closes each resource declared in the resource specification after the try block completes, whether normally or abruptly. This is the primary purpose of the construct: to ensure reliable resource cleanup without requiring an explicit finally block.

Answer

The resources must implement the Closeable interface.

Answer

Resources can be reassigned inside the try block.

Answer

Multiple resources are separated by commas.

Question 8

Which TWO statements about the java.util.Collections class are true?

Accepted Answer

Collections.synchronizedList(List) returns a synchronized list backed by the specified list.. Option D is correct because Collections.synchronizedList(List) returns a synchronized (thread-safe) list backed by the specified list. This method wraps the provided list in a synchronized wrapper, ensuring that all access to the underlying list is serialized when accessed through the returned list. It does not create a new independent list but provides a view that synchronizes all method calls.

Answer

Collections.sort(List) returns a new sorted list.

Answer

Collections.reverse(List) returns a new reversed list.

Answer

Collections.shuffle(List) returns a new shuffled list.

Question 9

Match each Java module directive to its description.

Accepted Answer

requires: Specifies a dependency on another module.. Correct matches: requires specifies dependencies, exports grants compile-time access, opens enables reflective access, provides declares service implementations. Common confusion is between exports and opens due to their related but distinct roles.

Answer

exports: Allows reflective access to a package.

Answer

opens: Makes a package accessible to other modules.

Question 10

Match each Java 17 feature to its description.

Accepted Answer

Sealed Classes: A feature that allows a class or interface to restrict which other classes or interfaces may extend or implement it.. These are key features introduced or enhanced in recent Java versions including 17.

Answer

Enhanced NullPointerExceptions: A feature that allows a class to restrict which subclasses can implement it.

Answer

Switch Expressions: A preview feature that allows testing an expression against a pattern using switch.

Question 11

Which TWO are true about HashSet and TreeSet?

Accepted Answer

HashSet uses equals() and hashCode() for uniqueness, TreeSet uses compareTo() or Comparator.. Option B is correct because HashSet relies on the equals() and hashCode() methods to determine element uniqueness, while TreeSet uses the natural ordering (compareTo()) or a provided Comparator to maintain sorted order and check for duplicates. This distinction is fundamental to how these Set implementations enforce uniqueness.

Answer

HashSet maintains elements in insertion order.

Answer

Both implement the List interface.

Answer

Both guarantee constant-time performance for basic operations (add, remove, contains).

Question 12

Given:
String[] array = {"A", "B"};
List<String> list = Arrays.asList(array);
list.set(0, "C");
array[1] = "D";
What is the content of the list?

Accepted Answer

[C, D]. Option B is correct because `Arrays.asList()` returns a fixed-size list backed by the original array. Modifications to the list via `set()` directly affect the backing array, and modifications to the array elements are reflected in the list. After `list.set(0, "C")`, the first element of both the list and the array becomes "C". After `array[1] = "D"`, the second element of both becomes "D". Thus the list content is [C, D].

Answer

[A, D]

Answer

[A, B]

Answer

[C, B]

Question 13

Which TWO statements about HashMap are true? (Select two.)

Accepted Answer

It allows null values.. Option A is correct because HashMap allows null values; you can store null as a value for any key, including null keys. This is explicitly permitted by the HashMap specification, which does not restrict value types.

Answer

It uses red-black trees for collision resolution.

Answer

It guarantees insertion order.

Answer

It is thread-safe.

Question 14

Which THREE are methods of the Map.Entry interface? (Java 17)

Accepted Answer

getValue(). Option A is correct because the Map.Entry interface in Java defines the getValue() method, which returns the value associated with the entry's key. This method is part of the core contract for accessing key-value pairs within a Map.

Answer

getHash()

Answer

getValueOrDefault()

Question 15

Which Map implementation guarantees that keys are sorted in their natural order?

Accepted Answer

TreeMap. TreeMap implements the SortedMap interface, which ensures that keys are stored in their natural ordering (as defined by Comparable) or by a provided Comparator. This makes TreeMap the only standard Map implementation that guarantees sorted keys without external sorting.

Answer

Hashtable

Answer

LinkedHashMap

Answer

HashMap

Question 16

Given: Set set = new HashSet<>(List.of(1,2,3)); List list = new ArrayList<>(set); Collections.sort(list); System.out.println(list); What is the output?

Accepted Answer

[1,2,3]. The code creates a HashSet from a List of 1, 2, 3, then copies it into an ArrayList. HashSet does not guarantee order, but Collections.sort() sorts the list in natural ascending order (1, 2, 3). The output is [1,2,3], making option C correct.

Answer

[3,2,1]

Answer

Compilation fails

Answer

[1,2]

Answer

[1,3,2]

Question 17

A developer needs to iterate over an ArrayList of integers and remove all elements that are less than 10. Which approach is best to avoid ConcurrentModificationException?

Accepted Answer

Use list.removeIf() with a lambda expression.. Option D is correct because `list.removeIf()` is a built-in method introduced in Java 8 that safely removes elements from a collection based on a predicate, handling all iteration and modification internally without throwing ConcurrentModificationException. It uses an internal iterator that properly coordinates structural modifications, making it the most concise and reliable approach for this task.

Answer

Use a for loop with index and list.remove(index) decrementing index.

Answer

Use an Iterator with iterator.remove().

Answer

Use a for-each loop with list.remove().

Question 18

Given: Map map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.entrySet().stream().filter(e -> e.getKey() > 1).forEach(System.out::print); What is output?

Accepted Answer

2=two. The filter(e -> e.getKey() > 1) retains only the entry with key 2, which is "2=two". The forEach(System.out::print) prints that entry without a newline, so the output is "2=two". Option D is correct.

Answer

2=two1=one

Answer

1=one2=two

Answer

No output

Question 19

Which of the following correctly converts an array of strings to a List?

Accepted Answer

Arrays.asList(array) returns a fixed-size list backed by the array.. Option C is correct because `Arrays.asList(array)` returns a fixed-size list backed by the original array, meaning changes to the list (like `set`) reflect in the array, but structural modifications (like `add` or `remove`) throw `UnsupportedOperationException`. This is the standard, exam-relevant way to convert an array to a List in Java.

Answer

Collections.toList(array) converts the array.

Answer

List.of(array) returns a mutable list.

Answer

Arrays.asList(array) returns a new ArrayList with a copy of the elements.

Question 20

A team uses a TreeSet with a custom Comparable that returns 0 for objects that are not logically equal (e.g., based on one field but objects differ in another). What is the likely outcome when adding such objects?

Accepted Answer

The second object is not added because TreeSet considers it a duplicate. TreeSet uses the compareTo() method of the Comparable interface (or Comparator) to determine ordering and equality. When compareTo() returns 0 for two objects that are not logically equal (e.g., they share the same field used in comparison but differ in other fields), TreeSet treats them as duplicates and does not add the second object. This is because TreeSet relies on the comparison result, not the equals() method, for uniqueness.

Answer

The second object replaces the first

Answer

A ClassCastException is thrown

Answer

Both objects are added and insertion order is preserved