1Z0-829 Practice Questions

The code fragment is using the Stream API to perform a reduction operation on a list of

ElectricProduct objects. The reduction operation consists of three parts: an identity value, an

accumulator function, and a combiner function. The identity value is the initial value of the result,

which is 0.0 in this case. The accumulator function is a BiFunction that takes two arguments: the

current result and the current element of the stream, and returns a new result. In this case, the

accumulator function is (a,b) -> a + b.getPrice (), which means that it adds the price of each element

to the current result. The combiner function is a BinaryOperator that takes two partial results and

combines them into one. In this case, the combiner function is (a,b) -> a + b, which means that it

adds the two partial results together.

The code fragment then applies a filter operation on the stream, which returns a new stream that

contains only the elements that match the given predicate. The predicate is p -> p.getPrice () > 10,

which means that it selects only the elements that have a price greater than 10. The code fragment

then applies a map operation on the filtered stream, which returns a new stream that contains the

results of applying the given function to each element. The function is p -> p.getName (), which

means that it returns the name of each element.

The code fragment then calls the collect method on the mapped stream, which performs a mutable

reduction operation on the elements of the stream using a Collector. The Collector is

Collectors.joining (“,”), which means that it concatenates the elements of the stream into a single

String, separated by commas.

The code fragment then prints out the result of the reduction operation and the result of the collect

operation, separated by a new line. The result of the reduction operation is 300.00, which is the sum

of the prices of all ElectricProduct objects that have a price greater than 10. The result of the collect

operation is CellPhone,ToyCar,Motor,Fan, which is the concatenation of the names of all

ElectricProduct objects that have a price greater than 10.

Therefore, the output of the code fragment is:

300.00 CellPhone,ToyCar,Motor,Fan

Reference: Stream (Java SE 17 & JDK 17) - Oracle, Collectors (Java SE 17 & JDK 17) - Oracle

The answer is B because a bottom-up migration is a strategy for modularizing an existing application

by moving its dependencies to the module path one by one, starting from the lowest-level libraries

and ending with the application itself. This way, each module can declare its dependencies on other

modules using the module-info.java file, and benefit from the features of the Java Platform Module

System (JPMS), such as reliable configuration, strong encapsulation, and service loading.

Option A is incorrect because a top-down migration is a strategy for modularizing an existing

application by moving it to the module path first, along with its dependencies as automatic modules.

Automatic modules are non-modular JAR files that are treated as modules with some limitations,

such as not having a module descriptor or a fixed name. A top-down migration allows the application

to use the module path without requiring all of its dependencies to be modularized first.

Option C is incorrect because a top-down migration does not require any specific order of migrating

modules, as long as the application is moved first and its dependencies are moved as automatic

modules. A bottom-up migration, on the other hand, requires the required modules to migrate

before the modules that depend on them.

Option D is incorrect because unnamed modules are not automatic modules in any migration

strategy. Unnamed modules are modules that do not have a name or a module descriptor, such as

classes loaded from the class path or dynamically generated classes. Unnamed modules have

unrestricted access to all other modules, but they cannot be accessed by named modules, except

through reflection with reduced security checks. Reference:

Oracle Certified Professional: Java SE 17 Developer

Java SE 17 Developer

OCP Oracle Certified Professional Java SE 17 Developer Study Guide

Migrating to Modules (How and When) - JavaDeploy

Java 9 Modularity: Patterns and Practices for Developing Maintainable Applications

The code fragment is comparing the values of a, b, and c using the operators. The first

comparison, d, is checking if a is less than b and greater than c. Since a is equal to 2, b is equal to -2,

and c is equal to -4, this comparison will evaluate to true. The second comparison, e, is checking if a

is greater than b and a is greater than c. Since a is equal to 2, b is equal to -2, and c is equal to -4, this

comparison will evaluate to false. Therefore, the result will be true 1 false 2. Reference: Operators

(The Java™ Tutorials > Learning the Java Language - Oracle

The code is defining an enum class called Forecast with three values: SUNNY, CLOUDY, and RAINY. The

toString() method is overridden to always return “SNOWY”. In the main method, the ordinal value of

SUNNY is printed, which is 0, followed by the value of CLOUDY converted to uppercase, which is

“CLOUDY”. However, since the toString() method of Forecast returns “SNOWY” regardless of the

actual value, the output will be “0 SNOWY”. Reference: Enum (Java SE 17 & JDK 17), Enum.EnumDesc

(Java SE 17 & JDK 17)

The code fragment is trying to read an object from a file using the ObjectInputStream class. This class

throws an IOException and a ClassNotFoundException. To handle these exceptions, the main method

signature should declare that it throws these exceptions. Otherwise, the code will not compile. If the

main method throws these exceptions, the code will print Wagon : 200, which is the result of calling

the

toString

method

of

the

LuxuryCar

object

that

was

written

to

the

file. Reference: ObjectInputStream (Java SE 17 & JDK 17) - Oracle, ObjectOutputStream (Java SE 17 &

JDK 17) - Oracle

The answer is A because the code fragment uses the ZoneId and ZonedDateTime classes to create

two date-time objects with the same local date-time but different zone offsets. The ZoneId class

represents a time-zone ID, such as America/Chicago, and the ZonedDateTime class represents a date-

time with a time-zone in the ISO-8601 calendar system. The code fragment creates two

ZonedDateTime objects with the same local date-time of 2021-11-07T01:30, but different zone IDs of

America/Chicago and UTC. The code fragment then compares the two objects using the equals and

isEqual methods.

The equals method compares the state of two objects for equality. In this case, it compares the local

date-time, zone offset, and zone ID of the two ZonedDateTime objects. Since the zone offsets and

zone IDs are different, the equals method returns false.

The isEqual method compares the instant of two temporal objects for equality. In this case, it

compares the instant of the two ZonedDateTime objects, which is derived from the local date-time

and zone offset. Since DST in Chicago ended on November 7th at 2 AM in 2021, the local date-time of

2021-11-07T01:30 in America/Chicago corresponds to the same instant as 2021-11-07T06:30 in UTC.

Therefore, the isEqual method returns true.

Hence, the output is true false. Reference:

Oracle Certified Professional: Java SE 17 Developer

Java SE 17 Developer

OCP Oracle Certified Professional Java SE 17 Developer Study Guide

ZoneId (Java Platform SE 8 )

ZonedDateTime (Java Platform SE 8 )

Time Zone & Clock Changes in Chicago, Illinois, USA

Daylight Saving Time Changes 2023 in Chicago, USA

The code fragment is creating a Duration object with a value of 5000 milliseconds, then printing it.

Then, it is creating another Duration object with a value of 60 seconds, then printing it. Finally, it is

creating a Period object with a value of 6 days, then printing it. The output will be

“PT5000PT60MP6D”. Reference:

https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html,

https://docs.oracle.com/javase/8/docs/api/java/time/Period.html

The answer is E because the code fragment creates a new Pet object with the name “Dog” and

assigns it to the variable p. Then, it assigns p to p1. Next, it changes the name of p1 to “Cat”. Then, it

assigns p1 to p. Finally, it sets p to null and prints the name of p and p1. The output will be “Cat” and

“null” because p is set to null and p1 still points to the Pet object with the name “Cat”.

The answer is C because the code fragment contains a syntax error in line 7, where the method

display is declared without any parameter type. This causes a compilation error, as Java requires the

parameter type to be specified for each method parameter. To fix this error, the parameter type

should be added before the parameter name, such as string design. This will enable the code to

compile and run without any errors. Reference:

Oracle Certified Professional: Java SE 17 Developer

Java SE 17 Developer

OCP Oracle Certified Professional Java SE 17 Developer Study Guide

Java Methods

The code fragment is using the Java SE 17 API to get the current time and then truncating it to

minutes. The result will be the current time truncated to minutes, which is why option B is

correct. Reference:

https://education.oracle.com/products/trackp_OCPJSE17

https://mylearn.oracle.com/ou/learning-path/java-se-17-developer/99487

https://docs.oracle.com/javase/17/docs/api/java.base/java/time/Instant.html#truncatedTo(java.tim

e.temporal.TemporalUnit)