1Z0-829 Practice Test 26 — 15 Questions

Question 1

Refer to the exhibit. What is the most likely cause of this exception?

Accepted Answer

The file contains non-object data (e.g., text) instead of a serialized Java object.. A `java.io.StreamCorruptedException` with the message 'invalid stream header: 546F6D' indicates that the input stream does not begin with the expected magic number `0xACED` (the standard Java serialization stream header). The hex value `546F6D` corresponds to the ASCII string 'Tom', which is plain text, not serialized object data. This occurs when a file containing non-object data (e.g., text) is read by `ObjectInputStream`.

Answer

The serialized object was tampered with after serialization.

Answer

The serial version UIDs of the class and stream do not match.

Answer

The stream's magic number is wrong due to a network error.

Question 2

A developer writes: List list = new ArrayList<>(); list.add("A"); list.add("B"); list.add(1, "C"); System.out.println(list); What is the output?

Accepted Answer

[A, C, B]. The `add(int index, E element)` method inserts the element at the specified index, shifting subsequent elements to the right. Initially, the list is [A, B]. After `list.add(1, "C")`, "C" is inserted at index 1, moving "B" to index 2, resulting in [A, C, B].

Answer

[A, B, C]

Answer

[A, B]

Answer

[C, A, B]

Question 3

What does the following code print?

List<Integer> list = List.of(1, 2, 3, 4, 5);
list.stream().filter(i -> i % 2 == 0).forEach(System.out::print);

Accepted Answer

24. The stream filters only even numbers (i % 2 == 0) from the list, producing 2 and 4, which are then printed sequentially via forEach. The filter operation retains elements where the predicate is true, so only 2 and 4 satisfy the condition.

Answer

No output

Answer

12345

Answer

135

Question 4

Which TWO are true about HashSet and TreeSet?

Accepted Answer

HashSet uses equals() and hashCode() for uniqueness, TreeSet uses compareTo() or Comparator.. Option B is correct because HashSet determines element uniqueness through the equals() and hashCode() contract (hashing into buckets and comparing with equals()), whereas TreeSet is a sorted set that relies on natural ordering via Comparable.compareTo() or an explicit Comparator to detect duplicates and order elements. Option E is correct because TreeSet's red-black tree implementation must compare elements to place them, so elements must implement Comparable (mutually comparable) unless a Comparator is supplied to the constructor. Option A is wrong because HashSet makes no ordering guarantee at all—insertion order is preserved by LinkedHashSet, not HashSet. Option C is wrong because both HashSet and TreeSet implement the Set interface (and NavigableSet/SortedSet for TreeSet), not List. Option D is wrong because TreeSet's basic operations run in O(log n) due to its balanced tree, and even HashSet only offers constant-time average performance, not a guarantee, since collisions can degrade operations toward O(n).

Answer

HashSet maintains elements in insertion order.

Answer

Both implement the List interface.

Answer

Both guarantee constant-time performance for basic operations (add, remove, contains).

Question 5

A class implements Serializable. Which modification ensures that a specific field (password) is not included in the serialized stream?

Accepted Answer

Declare the field as transient. The `transient` modifier is the correct mechanism in Java to exclude a specific field from the default serialization process. When a class implements `Serializable`, all non-transient instance fields are serialized by default. Marking the `password` field as `transient` ensures it is skipped during serialization and restored as `null` (or default value) upon deserialization.

Answer

Declare the field as volatile

Answer

Declare the field as static

Answer

Declare the field as final

Question 6

Which three are terminal operations of the Stream interface? (Choose three.)

Accepted Answer

reduce. Option C, reduce, is a terminal operation because it consumes the stream's elements and produces a single combined result (such as a sum or concatenation), triggering the pipeline's execution. Option D, forEach, is terminal since it iterates over each element to perform a side effect and returns void, closing the stream. Option E, collect, is terminal because it gathers the stream's elements into a mutable result container like a List or Set via a Collector, ending the stream pipeline. Options A (filter) and B (map) are not terminal; they are intermediate operations that return a new Stream and are lazy, only executing when a terminal operation is invoked.

Answer

filter

Answer

map

Question 7

A developer is writing a Java 17 application that must read a text file line by line and process each line. The file is encoded in UTF-8 and may contain characters outside the ASCII range. Which class should be used to read the file efficiently while correctly handling the character encoding?

Accepted Answer

BufferedReader with InputStreamReader using StandardCharsets.UTF_8. BufferedReader combined with InputStreamReader using UTF-8 provides efficient buffered reading and correct character decoding. It allows reading line by line with readLine, making it ideal for processing text files with multibyte characters.

Answer

RandomAccessFile

Answer

Scanner

Answer

FileInputStream

Question 8

A developer writes the following code: List<String> list = List.of("a", "b", "c"); list.set(0, "z"); What is the result?

Accepted Answer

The code compiles but throws UnsupportedOperationException at runtime.. The List.of factory method returns an unmodifiable list. The set method is part of the List interface, so the code compiles, but the implementation throws UnsupportedOperationException at runtime. This is consistent with other unmodifiable collections such as those returned by Collections.unmodifiableList and Set.of.

Answer

The code does not compile because List.of returns an immutable list that has no set method.

Answer

The code compiles and runs, but the set operation is silently ignored.

Answer

The code compiles and runs, and the list becomes ["z", "b", "c"].

Question 9

A developer writes a class `Vehicle` with a protected method `startEngine()`. A subclass `Car` in a different package extends `Vehicle` and overrides `startEngine()` with package-private access. What is the result?

Accepted Answer

Compilation fails because the overriding method cannot have weaker access privileges than the overridden method.. An overriding method must not have weaker access than the overridden method. A protected method can be overridden by a protected or public method, but not by a package-private one. Since `Car`'s method is package-private, it is less accessible, causing a compile-time error. The package difference is irrelevant to this rule.

Answer

Compilation fails because protected methods cannot be overridden in subclasses located in different packages.

Answer

Compilation succeeds, and the method is overridden correctly because `Car` is in a different package.

Answer

Compilation succeeds, but the method is not overridden; it is considered a new method with no relation to the superclass method.

Question 10

A developer writes a class `Counter` with a private int field `count` and a method `public void increment() { count++; }`. Another class in the same package tries to access `counter.count` directly. What is the result?

Accepted Answer

Compilation fails because `count` is private and not accessible from another class.. Private access is the most restrictive; it allows access only within the body of the top-level class where the member is declared. Other classes, even in the same package, cannot access private members. The compiler detects this and issues an error. To provide controlled access, the class should expose a public method or a getter, as it does with increment.

Answer

Compilation succeeds because both classes are in the same package.

Answer

Compilation succeeds but a runtime exception is thrown when accessing `count`.

Answer

Compilation succeeds because the field is accessed from a class in the same package, which is allowed for private members.

Question 11

A developer is designing a class hierarchy for a graphics application. The base class `Shape` has a method `draw()` that returns a `String` describing the shape. Subclasses like `Circle` and `Square` override `draw()`. The developer wants to ensure that when a `Shape` reference points to a subclass object, the subclass's `draw()` is invoked. Which two statements about method overriding and dynamic dispatch are correct? (Choose two.)

Accepted Answer

The method in the subclass must have the same name, parameter list, and return type (or a covariant return type) as the method in the superclass.. Overriding requires matching signatures and non-reduced visibility. The `final` modifier prevents overriding, and dynamic dispatch uses the actual object type at runtime. Static methods are hidden, not overridden. These rules ensure that polymorphism works correctly when using superclass references to invoke subclass-specific behavior.

Answer

The access modifier of the overriding method can be more restrictive than the overridden method, such as changing from `public` to `private`.

Answer

Dynamic dispatch is resolved at compile time based on the declared type of the reference variable, not the actual object type.

Answer

Static methods can be overridden to provide polymorphic behavior, and the version called depends on the object type at runtime.

Question 12

A developer is using a HashMap to count occurrences of words. The developer writes: Map counts = new HashMap<>(); counts.put("apple", 1); counts.put("banana", 2); counts.compute("apple", (k, v) -> v + 1); counts.computeIfAbsent("cherry", k -> 0); counts.computeIfPresent("banana", (k, v) -> null); System.out.println(counts); What is the result?

Accepted Answer

{apple=2, cherry=0}. The compute method updates apple to 2. computeIfAbsent adds cherry with value 0 because the function returns 0. computeIfPresent removes banana because the remapping function returns null, which causes removal. The final map contains apple=2 and cherry=0. The other options incorrectly include banana, show null for cherry, or omit cherry.

Answer

{apple=2, cherry=null}

Answer

{apple=2}

Answer

{apple=2, banana=2, cherry=0}

Question 13

A developer writes the following code:

int x = 3;
switch (x) {
    case 1:
        System.out.print("One");
    case 2:
        System.out.print("Two");
    case 3:
        System.out.print("Three");
    case 4:
        System.out.print("Four");
        break;
    default:
        System.out.print("Default");
}

What is the output?

Accepted Answer

ThreeFour. The switch statement uses fall-through behavior because there is no break after case 3. Starting at case 3 (since x equals 3), it prints 'Three', then falls through to case 4, prints 'Four', and then encounters a break, which terminates the switch. The default case is not executed because a matching case was found and fall-through did not reach it. Thus, the output is 'ThreeFour'.

Answer

Default

Answer

Three

Answer

ThreeFourDefault

Question 14

A developer is writing a method that takes a List<String> named names and must return a single String consisting of the names joined by a comma, where null elements are replaced with the literal text "UNKNOWN". The developer writes:

String result = names.stream()
    .map(n -> n == null ? "UNKNOWN" : n)
    .collect(Collectors.joining(","));

Which statement about this code is true?

Accepted Answer

It compiles and produces the expected joined string because Collectors.joining concatenates the mapped stream elements with the given delimiter.. The map operation replaces each null with the literal "UNKNOWN" before the collector runs, so Collectors.joining receives a stream of non-null strings and concatenates them with commas. The single-argument joining collector is valid and needs no prior toList. The pipeline both compiles and produces the expected comma-separated output.

Answer

It compiles but always returns an empty string because the delimiter argument is ignored when the stream contains more than one element.

Answer

It throws a NullPointerException at runtime because Collectors.joining does not accept null elements in the stream.

Answer

It fails to compile because Collectors.joining requires a Collectors.toList() call before it can be used with a delimiter.

Question 15

Given the following code:

```java
class Base {
    protected void print() { System.out.print("Base"); }
}
class Derived extends Base {
    public void print() { System.out.print("Derived"); }
    public static void main(String[] args) {
        Base b = new Derived();
        b.print();
    }
}
```
What is printed?

Accepted Answer

Derived. The overridden method in Derived is selected at runtime because Java uses dynamic dispatch for instance methods. The reference type Base only determines which methods are callable at compile time; the actual object type determines which implementation runs. Widening access from protected to public is permitted, so the override is valid and the program prints Derived.

Answer

Compilation fails because the access modifier is widened.

Answer

Compilation fails because print() is protected in Base.

Answer

Base