1Z0-829 Practice Test 18 — 15 Questions

Question 1

Given the exhibit, which statement about calling this method is true?

Accepted Answer

It can be called as `ClassName.getEmpName(101)`.. A static method can be called directly on the class without creating an instance. The method `getEmpName` is static and returns a value, so it can be invoked as `ClassName.getEmpName(101)`. Instance methods require an object reference, and non-static methods cannot be called in a static context without an instance.

Answer

It must be called using the `new` keyword.

Answer

It can only be called from a static context, not from an instance.

Answer

It cannot be used because it contains a loop.

Question 2

Which of the following collections maintains elements in the order they were inserted?

Accepted Answer

LinkedHashSet. LinkedHashSet maintains a doubly-linked list running through all of its entries, which defines the iteration ordering as the order in which elements were inserted into the set. This is specified in the Java documentation for LinkedHashSet, making it the only collection among the options that guarantees insertion order.

Answer

None of the above

Answer

PriorityQueue

Answer

HashSet

Answer

TreeSet

Question 3

You are developing an online bookstore application. You have a list of Book objects, each with fields: String title, double price, and String genre. You need to generate a report that lists the total price of books in each genre, but only for genres where the average price is greater than $20.00. You are using Java 17 and streams. Which approach correctly accomplishes this task?

Accepted Answer

books.stream()
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.mapping(Book::getPrice, Collectors.toList())))
    .entrySet().stream()
    .filter(e -> e.getValue().stream().mapToDouble(Double::doubleValue).average().orElse(0) > 20)
    .collect(Collectors.toMap(Map.Entry::getKey,
             e -> e.getValue().stream().mapToDouble(Double::doubleValue).sum()));. It first groups books by genre, collecting prices into lists, then filters entries where the average price exceeds $20 using `mapToDouble` and `average()`, and finally sums the prices for those genres. This two-step process correctly computes the average per genre before filtering, then sums the total per genre.

Answer

books.stream()
    .filter(b -> b.getPrice() > 20)
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.summingDouble(Book::getPrice)));

Answer

books.stream()
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.averagingDouble(Book::getPrice)))
    .entrySet().stream()
    .filter(e -> e.getValue() > 20)
    .collect(Collectors.toMap(Map.Entry::getKey, e -> {
        return books.stream().filter(b -> b.getGenre().equals(e.getKey())).mapToDouble(Book::getPrice).sum();
    }));

Answer

books.stream()
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.summingDouble(Book::getPrice)))
    .entrySet().stream()
    .filter(e -> e.getValue() > 20)
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Question 4

Which THREE statements are true about the java.util.Collection and java.util.stream.Stream APIs? (Choose three.)

Accepted Answer

The Stream.forEach() operation processes elements in the encounter order of the stream only for sequential streams.. The Stream.forEach() operation respects the encounter order of the stream only for sequential streams. For parallel streams, the order is not guaranteed unless the stream is explicitly forced to be sequential or uses forEachOrdered(). This behavior is defined in the Stream API specification.

Answer

The Collection.forEach() method is inherited from the Collection interface.

Answer

The Collection interface inherits the stream() method from the Iterable interface.

Question 5

What is a key difference between a class and an interface in Java?

Accepted Answer

A class can contain instance variables, while an interface cannot.. Classes can have instance variables (state), while interfaces cannot (they only declare method signatures and constants). This is a fundamental Java OOP concept.

Answer

A class cannot be used in inheritance.

Answer

An interface is automatically updated when the implementing class changes.

Answer

An interface can be instantiated directly.

Question 6

Which two of the following are valid ways to exit a loop in Java?

Accepted Answer

label break. A labeled break statement allows you to exit an outer loop from within a nested loop by specifying the label of the outer loop. This is a valid control flow mechanism in Java, as defined in the Java Language Specification (JLS §14.15).

Answer

continue

Answer

System.exit(0)

Answer

throw new Exception()

Question 7

A developer is implementing a custom sort for a list of Employee objects. The Employee class has fields: String name, int age. The list must be sorted first by name (ascending, case-insensitive), then by age (descending). Which Comparator implementation correctly achieves this?

Accepted Answer

Comparator.comparing(Employee::getName, String.CASE_INSENSITIVE_ORDER).thenComparing(Comparator.comparingInt(Employee::getAge).reversed()). It first sorts by name using a case-insensitive comparator, then chains a reversed comparator for age, ensuring descending order for age while preserving the primary sort by name. The `thenComparing` method correctly applies the reversed age comparator as a secondary sort, which is essential for multi-field sorting where one field requires descending order.

Answer

Comparator.comparing(Employee::getName, String.CASE_INSENSITIVE_ORDER).thenComparingInt(Employee::getAge)

Answer

Comparator.comparingInt(Employee::getAge).reversed().thenComparing(Employee::getName, String.CASE_INSENSITIVE_ORDER)

Answer

Comparator.comparing(Employee::getName).thenComparingInt(Employee::getAge).reversed()

Question 8

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 9

A company runs a financial application that processes a stream of millions of transaction records daily. Each record is a 'Transaction' object with fields: id, amount, currency, timestamp. The system currently uses a parallel stream to group transactions by currency and compute the sum of amounts per currency, using the following code:
Map<String, Double> result = transactions.parallelStream()
    .collect(Collectors.groupingBy(Transaction::getCurrency, 
             Collectors.summingDouble(Transaction::getAmount)));
Recently, performance has degraded significantly. Analysis shows that the stream source is a LinkedList, and the operation involves a large number of distinct currencies (over 1000). The JVM is running on a machine with 4 cores. Which is the best course of action to improve performance?

Accepted Answer

Replace groupingBy with a custom concurrent collector using ConcurrentHashMap.. The performance degradation stems from the parallel stream using a shared `ConcurrentHashMap` internally for the `groupingBy` collector, which incurs significant overhead when merging partial results from many threads, especially with over 1000 distinct currencies. A custom concurrent collector using `ConcurrentHashMap` directly eliminates this merge overhead by allowing threads to update the map concurrently without synchronization bottlenecks, improving throughput on a 4-core machine.

Answer

Change the stream source to an ArrayList and use sequential stream.

Answer

Use a custom thread pool with ForkJoinPool to control parallelism.

Answer

Increase the parallelism level to 8.

Question 10

Given ArrayList numbers = new ArrayList<>(List.of(1,2,3,4)); Which statement will insert element 10 at index 2?

Accepted Answer

numbers.add(2,10);. The `ArrayList.add(int index, E element)` method inserts the specified element at the given index, shifting existing elements to the right. Here, `numbers.add(2,10)` inserts 10 at index 2, resulting in the list [1,2,10,3,4].

Answer

numbers.add(10,2);

Answer

numbers.set(2,10);

Answer

numbers.insert(2,10);

Question 11

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 12

You are developing a high-frequency trading application that processes a stream of market data ticks. Each tick is an immutable object containing timestamp, price, and volume. The ticks arrive in real time and must be stored in a collection for later analysis. The collection is accessed by multiple threads: one producer thread adds ticks, and multiple consumer threads periodically iterate to compute moving averages. The system must minimize latency for the producer and ensure that consumers see a consistent snapshot of data without interfering with ongoing writes. You initially used a synchronized ArrayList, but profiler results show high contention and poor throughput. You consider the following approaches. Which one best addresses the requirements?

Accepted Answer

Use a ConcurrentLinkedDeque for writes and have consumers obtain a consistent snapshot by calling toArray() on the deque. The toArray() operation is O(n) but provides a point-in-time view without blocking the producer.. ConcurrentLinkedDeque allows lock-free, non-blocking writes (ideal for low-latency producers) and calling toArray() provides a consistent, immutable snapshot of the deque at that instant without blocking concurrent modifications. This satisfies the requirement for multiple consumers to see a consistent view while the producer continues writing with minimal latency.

Answer

Replace ArrayList with CopyOnWriteArrayList, which provides thread-safety without explicit synchronization and allows concurrent iteration while modifications occur.

Answer

Use a ConcurrentLinkedDeque and have consumers acquire a read lock when iterating, while the producer uses a write lock. This provides fine-grained locking and reduces contention.

Answer

Maintain two synchronized ArrayLists. The producer writes to one list while consumers read from the other. Periodically, swap references using an AtomicReference. This allows lock-free reads after the swap.

Question 13

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 14

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

Accepted Answer

Parallel streams use the common ForkJoinPool by default.. Parallel streams in Java, by default, use the common ForkJoinPool (ForkJoinPool.commonPool()), which is a shared thread pool designed for parallel task execution. This pool is lazily initialized and has a default parallelism level equal to the number of available processors minus one, as per the ForkJoinPool implementation.

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 15

Which two statements are true about records in Java? (Choose two.)

Accepted Answer

Records provide a canonical constructor that initializes all components.. A record in Java implicitly provides a canonical constructor that accepts all the components declared in the record header and initializes them. This constructor is generated by the compiler unless a custom canonical constructor is explicitly defined, ensuring that all component fields are set upon instantiation.

Answer

Records can be abstract.

Answer

Records can extend other classes.

Answer

Records can have instance fields that are not part of the record component list.