1Z0-829 Practice Test 2 — 30 Questions

Question 1

A developer is reviewing code that uses Java 17 collections. Which two statements about the java.util.ArrayDeque class are correct? (Choose two.)

Accepted Answer

It can be used as a LIFO stack and as a FIFO queue.. ArrayDeque is a resizable-array implementation of the Deque interface. It prohibits null elements and supports both stack (LIFO) and queue (FIFO) operations through its Deque methods. It is not a List, is not thread-safe, and does not maintain sorted order. These characteristics make it a versatile and efficient choice for many single-threaded scenarios.

Answer

It implements the List interface.

Answer

It is thread-safe for concurrent use by multiple threads without external synchronization.

Answer

It maintains its elements in sorted order.

Question 2

A data analytics platform processes user activity logs. Each log entry is a LogRecord with fields: userId (int), action (String), timestamp (long). The requirement is to find the top 3 most active users (by count of actions) in the last hour. The logs are stored in a List<LogRecord> logs. The current solution sorts all records by userId and counts manually, but it's slow. The team decides to use streams with parallel processing. Which code correctly identifies the top 3 users?

Accepted Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.<Long, Long>comparingByValue().reversed()).limit(3).collect(Collectors.toList()). It first filters logs to only those within the last hour, then groups by userId and counts actions, sorts the resulting map entries by count in descending order, limits to the top 3, and collects the result. This uses parallelStream() for performance and correctly applies the required logic.

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByKey()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::action, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Question 3

Refer to the exhibit. Which statement about this Singleton implementation is correct?

Accepted Answer

It may still have a race condition due to instruction reordering.. The provided Singleton implementation uses double-checked locking without declaring the instance variable as volatile. Without volatile, the JVM may reorder instructions such that a thread reads a non-null reference to a partially constructed object, leading to a race condition. This is a classic pitfall in Java concurrency.

Answer

The volatile keyword is unnecessary.

Answer

It is thread-safe without any issues.

Answer

It will compile only if the constructor is public.

Question 4

Which TWO statements about Java interfaces are true? (Choose two.)

Accepted Answer

Interfaces can contain static methods with a body.. Option C is correct because since Java 8, interfaces may declare static methods that have a full implementation body; these methods belong to the interface itself and must be invoked via the interface name (e.g., InterfaceName.method()), not through an implementing instance. Option D is correct because since Java 9, interfaces may contain private methods (both private instance methods and private static methods) with bodies, which serve as helper methods for default and static methods and are not inherited by implementing classes. Option A is wrong because an interface can extend multiple interfaces using a comma-separated list (e.g., interface A extends B, C), not just one. Option B is wrong because interface fields are implicitly public static final, so they cannot be declared protected (or private, or package-private). Option E is wrong because default methods are provided to add method implementations to interfaces without breaking existing implementing classes, and they can be overridden by implementing classes, so they do not prevent overriding.

Answer

An interface can extend at most one other interface.

Answer

Fields in an interface can be declared as protected.

Answer

Default methods are used to prevent method overriding.

Question 5

Assuming the code runs in a multithreaded environment, which statement best describes the behavior?

Accepted Answer

It prints the doubled numbers in a non-deterministic order and results may contain missing or duplicate entries.. Using a parallel stream with a stateful lambda (e.g., modifying an external `results` list inside `peek` or `forEach`) introduces data races and non-deterministic behavior. The `peek` operation is not synchronized, so the order of printed doubled numbers is unpredictable, and concurrent modifications to the shared `results` list can cause missing or duplicate entries due to race conditions.

Answer

The code will compile but throw an exception at runtime because of the use of parallel stream with stateful lambda.

Answer

It prints the doubled numbers in order (2, 4, 6, 8) and results contains [1,2,3,4] in that order.

Answer

It may produce a ConcurrentModificationException because results is modified while iterating.

Question 6

Which THREE statements are true about the Java Platform editions? (Select three.)

Accepted Answer

Java ME provides a subset of Java SE APIs for embedded devices.. Java ME (Micro Edition) is designed for resource-constrained devices like sensors, mobile phones, and embedded systems. It provides a subset of the Java SE APIs, along with additional APIs tailored for small devices, such as the Connected Limited Device Configuration (CLDC) and the Mobile Information Device Profile (MIDP). This allows developers to write Java applications that run on devices with limited memory, processing power, and display capabilities.

Answer

Java ME (Micro Edition) is the same as Android SDK.

Answer

Java SE includes a full application server for enterprise applications.

Question 7

A financial services company runs a Java 17 application on a server with 8 GB RAM. The application reads daily transaction files in CSV format (each file is about 500 MB). It processes each line, validates it against a SQL database, and writes results to an output file. Recently, after processing about 60% of a file, the application crashes with an OutOfMemoryError: Java heap space. The heap size is set to 2 GB. The code uses Files.readAllLines() to load the entire file into a List<String>, then iterates. The team is evaluating solutions to avoid memory issues. Which approach is the best course of action?

Accepted Answer

Replace Files.readAllLines() with Files.lines() and process the stream line by line.. Files.readAllLines() loads the entire 500 MB CSV file into memory as a List, which causes the OutOfMemoryError when combined with other heap usage. Replacing it with Files.lines() returns a Stream that reads lines lazily, processing each line one at a time without holding the entire file in memory. This directly solves the heap space issue without requiring additional hardware or manual file splitting.

Answer

Increase the JVM heap size to 4 GB.

Answer

Enable class data sharing to reduce memory footprint.

Answer

Split the file into 100 MB chunks and process each chunk sequentially.

Question 8

An application needs to maintain a set of unique customer IDs (type String) and frequently check if an ID is already present. The set is expected to contain up to 100,000 IDs. The current implementation uses a TreeSet, but performance tests show that the contains() operation is slower than desired. The developer considers switching to a HashSet. However, the business requires that when iterating the set, IDs must appear in sorted order. The developer proposes to convert the HashSet to a sorted list each time iteration is needed. Iteration occurs rarely (once per hour). What is the best approach?

Accepted Answer

Use HashSet and sort when iteration is needed. The primary performance bottleneck is the contains() operation, which is O(log n) for TreeSet but O(1) average for HashSet. Since iteration with sorted order is required only once per hour, the cost of sorting the HashSet into a list (O(n log n)) is negligible compared to the frequent contains() checks. This trade-off optimizes for the dominant use case while still meeting the sorted iteration requirement.

Answer

Use ConcurrentSkipListSet

Answer

Use LinkedHashSet

Answer

Keep the TreeSet because it maintains sorted order

Question 9

Which TWO are valid lambda expressions? (Choose two.)
A. (int a, int b) -> a + b
B. a, b -> a + b
C. (a, b) -> a + b
D. (a, b) -> { a + b; }
E. (int a, b) -> a + b

Accepted Answer

(int a, int b) -> a + b. Option A is correct because a lambda expression may declare explicit parameter types, and when it does, the parameter list must be enclosed in parentheses: (int a, int b) -> a + b is valid syntax. Option C is correct because a lambda may use inferred parameter types, and with two or more inferred parameters the parentheses are required: (a, b) -> a + b is valid. Option B is invalid because a lambda parameter list with multiple parameters must be enclosed in parentheses, so a, b -> a + b is not legal. Option D is invalid because a block-bodied lambda must contain statements, and a + b; is an expression, not a statement, so it would not compile. Option E is invalid because Java does not allow mixing explicit and inferred parameter types in the same lambda parameter list, so (int a, b) -> a + b is illegal.

Answer

a, b -> a + b

Answer

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

Answer

(int a, b) -> a + b

Question 10

Which interface provides the ability to store key-value pairs and allows null keys?

Accepted Answer

HashMap. HashMap is the correct answer because it implements the Map interface, allows null keys (only one null key is permitted), and does not synchronize its operations, making it suitable for unsynchronized key-value storage. In contrast, ConcurrentHashMap, TreeMap, and Hashtable all prohibit null keys for various reasons, such as thread-safety guarantees or sorting requirements.

Answer

ConcurrentHashMap

Answer

TreeMap

Answer

Hashtable

Question 11

A developer is implementing a batch processing application that reads records from a list and processes them. The method uses a for loop with an index variable. Inside the loop, if a record is null, the developer wants to skip that iteration and continue with the next index. The developer writes: for (int i = 0; i < records.size(); i++) { if (records.get(i) == null) continue; process(records.get(i)); updateCounter(); } However, the counter is not updated correctly. The developer expects the counter to reflect the number of processed (non-null) records. What is the problem?

Accepted Answer

The continue statement skips the rest of the loop body, including the counter update.. The `continue` statement immediately jumps to the next iteration of the loop, skipping any remaining code in the current iteration. In this case, `updateCounter()` is placed after the `continue` in the loop body, so when a null record is encountered, the counter update is never executed, causing the counter to not reflect the number of processed (non-null) records.

Answer

The continue statement is only valid inside a while loop.

Answer

The continue statement should be replaced with a break.

Answer

The counter variable should be declared as volatile.

Question 12

An application uses `--add-opens java.base/java.lang=ALL-UNNAMED` to allow reflective access to `java.lang` internals from the classpath. After migrating to a module, the flag is changed to `--add-opens java.base/java.lang=com.example.app`. Yet reflective access still fails with `InaccessibleObjectException`. What is the most likely reason?

Accepted Answer

The reflective call is made from a different module than com.example.app.. `--add-opens` specifies which module's package is opened to which target module. When the flag is changed from `ALL-UNNAMED` to `com.example.app`, only code in the `com.example.app` module is granted reflective access. If the reflective call originates from a different module (e.g., a third-party library or another application module), the `InaccessibleObjectException` will still be thrown because that module is not listed as the target.

Answer

The class performing reflection is in an unnamed module.

Answer

The module does not read the module java.base.

Answer

The module name in --add-opens is misspelled.

Question 13

Which of the following creates an immutable map with two entries?

Accepted Answer

Map.of("a",1,"b",2). `Map.of()` returns an immutable map containing exactly the key-value pairs provided as arguments. This factory method was introduced in Java 9 and creates a fixed-size, unmodifiable map with the two entries "a"→1 and "b"→2.

Answer

new HashMap<>(Map.of("a",1,"b",2))

Answer

Collections.emptyMap()

Answer

None of the above

Answer

new HashMap<>()

Question 14

A developer is designing a method that processes a stream of Employee objects. The method needs to group employees by department and then, within each department, sort by salary in descending order, and collect the top 3 highest-paid employees per department into a list. Which approach correctly accomplishes this using streams?

Accepted Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.collectingAndThen(Collectors.toList(), list -> list.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3).collect(Collectors.toList())))). It uses `Collectors.groupingBy` to partition employees by department, then applies `Collectors.collectingAndThen` to post-process each department's list. Inside, it sorts the list by salary in descending order, limits to the top 3, and collects them into a new list. This ensures each department's result is independently sorted and truncated.

Answer

stream.collect(Collectors.toMap(Employee::getDepartment, e -> { List l = new ArrayList<>(); l.add(e); return l; }, (l1, l2) -> { l1.addAll(l2); l1.sort(Comparator.comparing(Employee::getSalary).reversed()); return l1.subList(0, Math.min(3, l1.size())); }))

Answer

stream.sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).values().stream().map(l -> l.subList(0, Math.min(3, l.size()))).collect(Collectors.toList())

Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).entrySet().stream().flatMap(e -> e.getValue().stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3)).collect(Collectors.toList())

Question 15

A developer is working on a high-performance trading application that processes market data. The system needs to maintain a sorted list of order IDs (Long values) that are frequently inserted and removed. The current implementation uses a TreeSet<Long> to store the order IDs. The application is experiencing performance degradation under high load, and profiling shows that the TreeSet operations are the bottleneck. The developer considers replacing the TreeSet with a data structure that offers O(log n) insertion and removal but also supports O(log n) indexed access (e.g., get by index) for batch processing. Which of the following should the developer choose to improve performance while maintaining the sorted order and adding indexed access?

Accepted Answer

No standard Java Collections class fulfills all requirements; consider a custom implementation.. No standard Java Collections class provides O(log n) insertion, removal, and O(log n) indexed access while maintaining sorted order. TreeSet offers O(log n) insertion/removal but lacks indexed access; ArrayList provides O(1) indexed access but requires O(n log n) sorting after each insertion; PriorityQueue offers O(log n) insertion/removal but only O(1) peek access, not indexed access. A custom data structure like an order statistic tree (e.g., a balanced binary search tree with subtree sizes) is needed to meet all requirements.

Answer

Replace with TreeMap<Long, Boolean> and use the key set for iteration and indexed access via keySet().toArray().

Answer

Replace with PriorityQueue<Long> and use poll() for removal and toArray() for indexed access.

Answer

Replace with ArrayList<Long> and use Collections.sort() after each insertion.

Question 16

Consider try-with-resources where resource1 is opened first, then resource2. During closing, both throw exceptions. Which exception is propagated to the caller?

Accepted Answer

The exception from resource2 (closed first) with resource1's exception as suppressed.. In try-with-resources, resources are closed in the reverse order of their declaration. Resource2 (declared second) is closed first, and resource1 (declared first) is closed last. If both throw exceptions during closing, the exception from the first resource closed (resource2) is propagated to the caller, and the exception from the second resource closed (resource1) is added as a suppressed exception. This matches option B.

Answer

The exception from resource1 (closed last) with resource2's exception as suppressed.

Answer

Only the exception from the resource declared first is propagated.

Answer

Both exceptions are wrapped in a new exception.

Question 17

What is the result of executing the following code snippet?

BigDecimal d1 = new BigDecimal("1.00");
BigDecimal d2 = new BigDecimal("1.0");
System.out.println(d1.equals(d2));

Accepted Answer

false. The `equals` method of `BigDecimal` compares both the numeric value and the scale (number of digits after the decimal point). Since `new BigDecimal("1.00")` has a scale of 2 and `new BigDecimal("1.0")` has a scale of 1, they are not considered equal by `equals`, even though they represent the same mathematical value. Therefore, the output is `false`.

Answer

compile error

Answer

true

Answer

1

Question 18

Which TWO are correct about parallel streams in Java? (Choose TWO.)

Accepted Answer

Parallel streams use the common ForkJoinPool by default.. Option D is correct because parallel streams in Java execute their tasks on the common ForkJoinPool by default, which is obtained via ForkJoinPool.commonPool() and sized to Runtime.getRuntime().availableProcessors() - 1. Option E is correct because parallel stream pipelines require stateless, non-interfering, and side-effect-free lambda functions; shared mutable state or interference between operations can produce nondeterministic or incorrect results due to concurrent execution across threads. Option A is wrong because parallelism adds overhead (splitting, task scheduling, merging) and can be slower than sequential streams for small data sets or cheap operations. Option B is wrong because lambdas that mutate shared state, rely on encounter order, or are not thread-safe can break under parallel execution. Option C is wrong because parallel streams do not guarantee encounter order unless the terminal operation and stream source explicitly preserve it (e.g., using forEachOrdered), and unordered sources or operations may yield results in any order.

Answer

Parallel streams always improve performance over sequential streams.

Answer

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

Answer

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

Question 19

Which TWO practices improve the security of Java serialization?

Accepted Answer

Mark sensitive fields as transient to exclude them from serialization.. Option B is correct because marking sensitive fields (e.g., passwords, keys) as transient excludes them from the default serialization process, so their values are never written to the byte stream and cannot be recovered by an attacker deserializing the object. Option D is correct because overriding readObject() lets you validate and sanitize field values after deserialization, rejecting malformed or malicious state before it is used, which mitigates gadget-chain and tampering attacks. Option A is not a security practice: throwing NotSerializableException from writeObject() merely prevents serialization of that class and does not protect against deserialization of crafted streams. Option C is wrong because serialVersionUID is only a version-compatibility identifier; a random value does not prevent malicious serialization and can actually break legitimate deserialization. Option E is not inherently secure: Externalizable gives full control over the wire format but shifts the burden of validation to the developer and, without explicit checks in readExternal(), can be just as vulnerable as default serialization.

Answer

Disable serialization by throwing NotSerializableException from writeObject().

Answer

Set a random serialVersionUID to prevent malicious serialization.

Answer

Use Externalizable for full control over serialization format.

Question 20

Which THREE conditions must be true for a method to override another method in a subclass? (Choose three.)

Accepted Answer

The method name must be the same.. Option C is correct because an overriding method must have exactly the same name as the method it overrides in the superclass, which is the fundamental basis for the override relationship. Option D is correct because the parameter list (number, types, and order of parameters) must match exactly; otherwise the method would be an overload, not an override. Option E is correct because Java permits covariant return types, meaning the overriding method's return type may be the same as, or a subtype of, the overridden method's return type. Option A is incorrect because static methods are hidden rather than overridden, and an instance method cannot override a static method. Option B is incorrect because the access modifier must be the same or less restrictive (wider), not more restrictive; a more restrictive modifier would cause a compile-time error.

Answer

The method must be static in the superclass.

Answer

The access modifier must be the same or more restrictive.