1Z0-829 Practice Test 29 — 15 Questions

Question 1

A developer writes the following code to partition a list of integers into even and odd numbers, then print the count of each group:

import java.util.*;
import java.util.stream.*;

public class PartitionExample {
    public static void main(String[] args) {

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); Map<Boolean, List<Integer>> partitioned = numbers.stream() .collect(Collectors.partitioningBy(n -> n % 2 == 0)); System.out.println(partitioned.get(true).size() + " " + partitioned.get(false).size());

}
}

What is the output?

Accepted Answer

5 5. The partitioningBy collector splits elements into two groups based on a predicate: true and false. It always includes both keys, even if one group is empty. With the list 1 to 10, there are five even and five odd numbers. The code retrieves the sizes of both lists and prints them separated by a space, yielding '5 5'.

Answer

4 5

Answer

5 4

Answer

Compilation fails because partitioningBy requires a downstream collector.

Question 2

A logistics company uses a Stream of shipment tracking codes. A developer writes: Stream codes = Stream.of("AB12", "CD34", "EF56"); Map> result = codes.collect(Collectors.partitioningBy(c -> c.startsWith("A"))); What is the value of result.get(false) after execution?

Accepted Answer

[CD34, EF56]. partitioningBy returns a Map with exactly two entries, one for true and one for false, each holding a List of matching elements. Since CD34 and EF56 do not start with "A", they land in the false partition, preserving encounter order. The true partition holds AB12, so result.get(false) yields the two non-matching codes.

Answer

[AB12, CD34, EF56]

Answer

[AB12]

Answer

null

Question 3

A developer defines an interface `Task` with a default method `execute()` that prints "Task". A class `Job` implements `Task` but also extends a class `Process` that has a public method `execute()` printing "Process". The class `Job` does not override `execute()`. What is the result when `new Job().execute()` is called?

Accepted Answer

It prints "Process" because the superclass method takes precedence over the interface default method.. The Java method resolution rules prioritize superclass methods over interface default methods. When a class inherits a concrete method from a superclass and a default method from an interface, the superclass implementation is chosen. This avoids ambiguity and preserves backward compatibility. Since `Job` does not override, the inherited `Process.execute()` is invoked, printing "Process".

Answer

It prints "Task" because the default method from the interface takes precedence over the superclass method.

Answer

It throws an exception at runtime because the JVM cannot decide which method to invoke.

Answer

It causes a compile-time error because of conflicting method implementations from the superclass and interface.

Question 4

A developer is writing a method that uses a try-with-resources statement with two resources: `ResourceA` and `ResourceB`, both implementing `AutoCloseable`. The code is:

```java
try (ResourceA a = new ResourceA(); ResourceB b = new ResourceB()) {
    // use a and b
}
```

If both `a.close()` and `b.close()` throw exceptions, which exception is propagated and what happens to the other?

Accepted Answer

The exception from `b.close()` is propagated, and the exception from `a.close()` is suppressed.. Try-with-resources closes resources in reverse order of declaration. The last declared resource is closed first. If multiple close operations throw, the first thrown exception (from the last declared resource) becomes the primary exception, and subsequent exceptions are suppressed and attached to it. This ensures that the most relevant exception is propagated while preserving all failure information.

Answer

The exception from `a.close()` is propagated, and the exception from `b.close()` is suppressed.

Answer

The exception from `a.close()` is propagated, and the exception from `b.close()` is ignored.

Answer

Both exceptions are propagated as a single exception with no suppression.

Question 5

A payroll service running on Java 17 must compute the exact net pay for an employee whose gross salary is 1234.567 and whose tax rate is 0.075. The result must be rounded to two decimal places using the rounding mode that rounds toward the nearest neighbor and, on a tie, toward the even digit. Which code snippet correctly produces that value?

Accepted Answer

BigDecimal gross = new BigDecimal("1234.567");
BigDecimal tax = gross.multiply(new BigDecimal("0.075"));
BigDecimal net = gross.subtract(tax).setScale(2, RoundingMode.HALF_EVEN);. Exact decimal arithmetic requires string-based BigDecimal construction, not double-based construction, because the double constructor stores the nearest binary approximation. Computing tax and net entirely with BigDecimal preserves every digit, and setScale(2, RoundingMode.HALF_EVEN) applies banker's rounding so exact ties go to the even digit as the payroll specification demands.

Answer

BigDecimal gross = new BigDecimal(1234.567);
BigDecimal tax = gross.multiply(BigDecimal.valueOf(0.075));
BigDecimal net = gross.subtract(tax).setScale(2, RoundingMode.HALF_EVEN);

Answer

double gross = 1234.567;
double net = BigDecimal.valueOf(gross * 0.925).setScale(2, RoundingMode.HALF_EVEN).doubleValue();

Answer

BigDecimal gross = new BigDecimal("1234.567");
BigDecimal net = gross.multiply(new BigDecimal("0.925")).setScale(2, RoundingMode.HALF_UP);

Question 6

A configuration loader must read numeric values from a properties file and convert them to primitives. Which two statements about the parse methods of the wrapper classes are correct? (Choose two.)

Accepted Answer

Integer.parseInt("1_000") throws a NumberFormatException.. The wrapper parse methods accept only plain decimal digit strings unless a radix overload is used. Underscores are a compile-time literal feature and are rejected at runtime, and valueOf returns a boxed object while parseInt returns a primitive. Suffixes, hexadecimal prefixes, and nonstandard boolean tokens such as yes are all rejected or misinterpreted, so configuration loaders must normalize input before parsing.

Answer

Boolean.parseBoolean("yes") returns true because yes is commonly treated as affirmative.

Answer

Double.parseDouble accepts a trailing d or f suffix such as "3.14d".

Answer

Long.parseLong("0x1F") returns 31 because hexadecimal notation is recognized.

Question 7

A configuration loader reads a duration string such as PT2H30M from a properties file and must convert it into a Duration object that other components can add to Instant values. The loader also needs to reject malformed input with a clear exception. Which statement about parsing this value is correct?

Accepted Answer

Duration.parse("PT2H30M") succeeds and yields a duration of 9000 seconds, while malformed input throws DateTimeParseException.. Duration.parse reads ISO-8601 time-based strings such as PT2H30M and produces a Duration measuring exact elapsed seconds, which is directly compatible with Instant arithmetic. Malformed text produces DateTimeParseException, giving the loader the clear rejection behavior it needs. The returned object is a Duration, not a Period, and the size of this value is far too small to cause overflow.

Answer

Duration.parse("PT2H30M") returns a Period of two hours and thirty minutes that must be converted before use.

Answer

Duration.parse("PT2H30M") throws DateTimeParseException because hours and minutes cannot be combined in one duration.

Answer

Duration.parse("PT2H30M") succeeds but throws ArithmeticException when the value is added to an Instant due to overflow.

Question 8

A Java 17 batch application defines a custom exception class `ParseException` that extends `Exception`. The method `parseConfig()` declares `throws ParseException` and reads a configuration file using `Files.newBufferedReader`. The method `load()` calls `parseConfig()` but contains no `try` block. Which statement describes the compilation result?

Accepted Answer

Compilation succeeds only if `load()` also declares `throws ParseException` or catches it.. A checked exception must be either caught or declared by any method that invokes a method declaring it. Since `ParseException` extends `Exception`, it is checked, and `load()` does neither. The compiler therefore rejects the code until `load()` declares `throws ParseException` or wraps the call in a `try`/`catch`. This is the standard catch-or-specify contract.

Answer

Compilation fails because `parseConfig()` must declare `throws IOException` instead of `ParseException`.

Answer

Compilation succeeds because `ParseException` is a custom class and the compiler cannot verify it.

Answer

Compilation succeeds because `parseConfig()` reads a file, and file operations are unchecked.

Question 9

A developer is writing a method that groups employees by department and then, for each department, computes the total salary. The code is:

Map<String, Double> totals = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment,
        Collectors.summingDouble(Employee::getSalary)));

Which statement best describes the type of the values in the resulting map and why?

Accepted Answer

The values are Double because the downstream collector summingDouble accumulates salary as a double.. The two-argument groupingBy overload takes a classifier and a downstream collector. The downstream collector summingDouble(Employee::getSalary) produces a Double result, and groupingBy stores that result as the map value. Therefore the result is Map<String, Double>, matching the declared variable. The other options incorrectly claim primitive, OptionalDouble, or Number value types, none of which match the collector's actual finisher type.

Answer

The values are Number because summingDouble is a generic collector that returns a Number to support both int and double salaries.

Answer

The values are double because the map stores primitive double values to avoid boxing.

Answer

The values are OptionalDouble because summingDouble wraps the result in an OptionalDouble to handle empty groups.

Question 10

A developer writes:

var d = LocalDate.of(2023, 2, 29);
System.out.println(d);

What is the result?

Accepted Answer

A DateTimeException is thrown at runtime.. LocalDate.of validates the day-of-month against the actual month length for the supplied year and throws DateTimeException when the combination is impossible. Because 2023 is not a leap year, February 29 does not exist, so the call fails at runtime rather than producing a date or rolling forward. Compilation is unaffected because the argument types are valid.

Answer

2023-03-01

Answer

Compilation fails because 2023, 2, and 29 are not valid LocalDate arguments.

Answer

2023-02-29

Question 11

A developer is creating a deep copy of a complex object graph. The class Person implements Cloneable and overrides clone() to perform a shallow copy. It has a field Address that is mutable and does not implement Cloneable. Which approach correctly achieves a deep copy of Person?

Accepted Answer

In Person.clone(), after calling super.clone(), create a new Address instance and assign it to the cloned Person's address field.. Deep copying requires creating independent copies of all mutable objects in the graph. Using super.clone() gives a shallow copy, so you must explicitly clone or recreate referenced objects. Since Address is not Cloneable, the simplest fix is to create a new Address with the same state and assign it to the cloned Person. This ensures no shared references.

Answer

Call super.clone() in Person.clone() and rely on the Address field being copied automatically because it's an object reference.

Answer

Make Address implement Cloneable and call address.clone() in Person.clone() without any other changes.

Answer

Use serialization to deep copy the Person object, but only if Address implements Serializable.

Question 12

A developer compiles a set of Java 17 source files into a directory named out and wants to run the main class com.example.Main while ensuring that only the classes in out are used. Which command accomplishes this?

Accepted Answer

java --class-path out com.example.Main. The java launcher uses the class path to find application classes. Specifying --class-path out restricts the search to the out directory, so only the compiled classes there are used. Other forms either misinterpret the argument type (a file path or a directory for -jar) or assume a modular layout that is not present.

Answer

java --module-path out --module com.example.Main

Answer

java -jar out

Answer

java -cp out com/example/Main.class

Question 13

A developer writes a labelled loop to search a two-dimensional grid of integers for a target value and must stop scanning entirely as soon as the target is found:

```java
int target = 9;
boolean found = false;
outer:
for (int[] row : grid) {
    for (int value : row) {
        if (value == target) {
            found = true;
            break outer;
        }
    }
}
```

What is the effect of the labelled break statement in this code?

Accepted Answer

It exits both the inner for-each loop and the outer labelled loop immediately, continuing after the outer loop.. A labelled break exits the loop identified by the label, no matter how deeply nested the break statement is. Naming the outer label therefore terminates both loops at once and transfers control to the statement following the outer loop, ending the grid scan the moment the target is encountered. An unlabelled break would stop only the inner loop.

Answer

It exits only the inner for-each loop and lets the outer loop continue with the next row.

Answer

It causes a compile-time error because break cannot reference a label on a for-each loop.

Answer

It restarts the outer loop from its first row and re-evaluates the grid from the beginning.

Question 14

A developer is using a nested loop to process a 4x4 grid. They want to skip the remaining iterations of the inner loop whenever the column index equals the row index, but continue with the next row. Which control flow statement should be placed inside the inner loop to achieve this?

Accepted Answer

continue;. The continue statement is designed to skip the current iteration of the innermost loop and proceed to the next iteration. In a nested loop, placing continue inside the inner loop when a condition is met (such as column equals row) will skip the rest of that inner loop's body for that specific iteration, then continue with the next column. This matches the requirement to skip the diagonal element while still processing other columns and moving to the next row.

Answer

break outer;

Answer

return;

Answer

break;

Question 15

A team is modeling a payment hierarchy. They need a base class `Payment` that requires every concrete subclass to implement a `process()` method, but also wants to provide a default implementation of `refund()` that subclasses may override. The base class should not be instantiable. Which declaration best meets these requirements?

Accepted Answer

public abstract class Payment { public abstract void process(); public void refund() { System.out.println("Refunded"); } }. An abstract class is the right construct when you need a non-instantiable base type that can mix abstract method contracts with concrete reusable behavior. Declaring process() abstract forces every concrete subclass to supply an implementation, while the concrete refund() method offers default behavior that subclasses may override. The other declarations either fail to enforce the mandatory method or do not represent an instantiable class hierarchy.

Answer

public class Payment { public void process(); public void refund() { System.out.println("Refunded"); } }

Answer

public interface Payment { void process(); default void refund() { System.out.println("Refunded"); } }

Answer

public abstract class Payment { public void process() { } public void refund() { System.out.println("Refunded"); } }