1Z0-829 Practice Test 33 — 15 Questions

Question 1

What is the output of the following code snippet? int x = 5; if(x > 0) { System.out.print('A'); } else if(x > 2) { System.out.print('B'); } else { System.out.print('C'); }

Accepted Answer

A. The condition `x > 0` evaluates to true (x = 5), so the code prints 'A' and then exits the entire if-else-if chain. The subsequent `else if` and `else` blocks are skipped entirely, so only 'A' is output.

Answer

AB

Answer

C

Answer

B

Question 2

A team is developing a real-time data processing pipeline that reads sensor data from a message queue. The pipeline uses a flatMap operation that calls an external geocoding service for each sensor reading. The external service has a rate limit of 10 requests per second and is slow (150ms average response time). The current code: sensorStream.parallelStream() .flatMap(reading -> getGeocode(reading).stream()) .forEach(system.out::println); The application is overloaded because parallel stream fires many concurrent requests, exceeding the rate limit and causing failures. They need to process all sensor data but must respect the rate limit. Which approach should they use?

Accepted Answer

Use a sequential stream with a custom rate limiter (e.g., a semaphore) that blocks when the limit is reached.. Using a sequential stream with a custom rate limiter (e.g., a Semaphore configured to allow only 10 permits per second) ensures that the external geocoding service is called at a controlled rate, preventing rate-limit violations. The sequential stream processes elements one at a time, and the rate limiter blocks the thread when the limit is reached, naturally throttling requests to stay within the 10 requests/second limit while still processing all data.

Answer

Reduce the parallelism level by using a custom thread pool with a fixed number of threads.

Answer

Use filter to drop some sensor readings to reduce the load.

Answer

Use a sequential stream and hope the processing completes within the time window.

Question 3

A financial application uses BigDecimal for monetary calculations. Which rounding mode should be used to round to the nearest neighbor, and if both neighbors are equidistant, round to the even neighbor?

Accepted Answer

RoundingMode.HALF_EVEN. RoundingMode.HALF_EVEN rounds to the nearest neighbor, and when both neighbors are equidistant (i.e., the fractional part is exactly 0.5), it rounds to the even neighbor. This is the standard rounding mode for financial calculations to minimize cumulative rounding bias over many operations.

Answer

RoundingMode.HALF_UP

Answer

RoundingMode.HALF_DOWN

Answer

RoundingMode.UNNECESSARY

Question 4

A developer needs to sort a List of Employee objects by salary (double) in descending order. Which approach is correct and efficient?

Accepted Answer

Collections.sort(list, (e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary()));. It uses `Collections.sort()` with a custom `Comparator` that performs an in-place sort of the original list, which is both efficient (no new list created) and correctly orders by salary descending via `Double.compare(e2.getSalary(), e1.getSalary())`. This avoids the overhead of stream pipeline creation and collection, and directly mutates the list as required.

Answer

Collections.sort(list, Collections.reverseOrder());

Answer

list.stream().sorted((e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary())).collect(Collectors.toList());

Answer

Collections.sort(list);

Question 5

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]. `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 6

Given: outer: for(int i=0; i<3; i++) { for(int j=0; j<3; j++) { if(j==1) continue outer; } } How many times does the innermost loop body execute?

Accepted Answer

3. The outer loop runs with i=0,1,2. For each i, the inner loop starts j=0, executes the body once, then j=1 triggers 'continue outer', which skips the rest of the inner loop and increments i. Thus the inner loop body executes exactly once per outer iteration, for a total of 3 times.

Answer

0

Answer

9

Answer

6

Question 7

Which of the following is a best practice when creating a custom exception class?

Accepted Answer

Extend RuntimeException for an unchecked exception.. Extending RuntimeException is the standard way to create a custom unchecked exception in Java. Unchecked exceptions do not require explicit handling via try-catch or throws clauses, making them suitable for programming errors like invalid arguments or illegal states. This aligns with Java's exception hierarchy where RuntimeException and its subclasses are unchecked.

Answer

Implement the Exception interface.

Answer

Extend Error to indicate a serious system error.

Answer

Extend Throwable directly to create a new exception type.

Question 8

A developer needs to parse a date string '2024-07-04' into a LocalDate object. Which approach is correct?

Accepted Answer

LocalDate.parse("2024-07-04"). `LocalDate.parse("2024-07-04")` uses the default ISO-8601 format (yyyy-MM-dd), which matches the given string exactly. The `LocalDate` class provides a static `parse` method that returns a `LocalDate` object without needing an explicit formatter when the input follows the standard pattern.

Answer

LocalDate.of(2024, 07, 04)

Answer

DateFormat.getDateInstance().parse("2024-07-04")

Answer

new LocalDate(2024, 7, 4)

Question 9

A developer is building a batch processing application that reads a large CSV file (approx. 5 GB) from a network file system, transforms each row, and writes the result to a database. The initial implementation uses Files.lines(path) to obtain a Stream<String>, processes each line with forEach, and then does not explicitly close the stream. After running for several minutes, the application slows down, and eventually throws an IOException: 'Too many open files'. The database writes are also failing intermittently. The developer needs to fix the application. The environment is Java 17 on Linux with default settings. Which course of action best resolves the issues?

Accepted Answer

Wrap the Files.lines call in a try-with-resources block to ensure the stream is closed automatically.. `Files.lines(path)` returns a lazily populated `Stream<String>` that holds a file handle open. Without an explicit close, the underlying `FileChannel` and file descriptor are not released, leading to 'Too many open files' after processing many lines. Wrapping the stream in a try-with-resources block ensures `close()` is called automatically, releasing the file descriptor and preventing resource exhaustion.

Answer

Use FileInputStream with a buffered byte array and manually scan for newline characters.

Answer

Replace Files.lines with Files.newBufferedReader, wrapping it in a try-with-resources block.

Answer

Use Files.readAllLines to load the entire file into memory and then iterate over the list.

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

{apple=3, banana=2, orange=1}. The code processes a list containing the strings "apple", "banana", "orange", "apple", "banana", "apple" (or an equivalent stream) and uses `Collectors.groupingBy(Function.identity(), Collectors.counting())` to create a frequency map. The `groupingBy` collector groups the elements by their identity (the string itself) and the downstream `counting()` collector counts the occurrences in each group, resulting in a map where the key is the string and the value is the count: apple appears 3 times, banana 2 times, and orange 1 time.

Answer

{apple=2, banana=2, orange=2}

Answer

{1=[apple, banana, orange], 2=[apple, banana], 3=[apple]}

Answer

{apple=3, banana=1, orange=1}

Question 11

Refer to the exhibit. What is the output?

Accepted Answer

true
true. The code uses `equals()` on two `String` objects with the same content ("Test"), which returns `true`. The second `println` uses `==` to compare the same two `String` references; since both reference the same string literal from the string pool, `==` also returns `true`. Thus both lines print `true`.

Answer

Compilation fails

Answer

true
false

Answer

false
true

Question 12

Given the exhibit showing a compilation error at line 5 of Test.java, which of the following code fragments could be at that line?

Accepted Answer

FileInputStream fis = new FileInputStream("test.txt");. The code at line 5 is a checked exception (FileNotFoundException) that must be handled or declared. The compilation error indicates that the method containing line 5 does not handle or declare this checked exception, which is required by the Java compiler.

Answer

int x = 5;

Answer

try { ... } catch (Exception e) { }

Answer

System.out.println("Hello");

Question 13

A developer places a non-modular JAR file on the module path. What type of module does this JAR become?

Accepted Answer

Automatic module. When a non-modular JAR is placed on the module path, the Java module system automatically derives a module from it, known as an automatic module. This is because the JAR lacks a module-info.class, so the system infers a module name from the JAR filename (e.g., using the Main-Class attribute or the JAR's name) and exports all packages, giving it access to all other modules. Option C is correct because the JAR becomes an automatic module, not a named or unnamed module.

Answer

Open module

Answer

Named module

Answer

Unnamed module

Question 14

Given the above Java version, which of the following is NOT a standard Java 17 feature?

Accepted Answer

Pattern matching for switch (preview). Pattern matching for switch is a preview feature in Java 17, not a standard feature. It was introduced as a preview under JEP 406 and requires the --enable-preview flag to be used. Standard features in Java 17 are finalized and do not require any preview flags.

Answer

All of the above are standard

Answer

Sealed classes

Answer

Text blocks

Answer

Records

Question 15

Which TWO are terminal operations on the Stream interface? (Choose two.)

Accepted Answer

count(). A is correct because `count()` is a terminal operation that reduces the stream to a single `long` value by counting the number of elements after processing the pipeline. It triggers the stream pipeline execution and consumes the stream, making it a terminal operation per the `Stream` interface specification.

Answer

filter()

Answer

map()

Answer

sorted()