1Z0-829 Practice Test 4 — 10 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