Question 1

Given:
What is the result?

Accepted Answer

The answer is C because the code demonstrates the concept of method overloading and type conversion in Java. Method overloading allows different methods to
have the same name but different parameters. Type conversion allows values of one data type to be assigned to another data type, either automatically or
explicitly. In the code, the class Test has four methods named sum, each with different parameter types: int, float, and double. The main method creates an
instance of Test and calls the sum method with different arguments. The compiler will choose the most specific method that matches the arguments, based on the
following rules:
? If there is an exact match between the argument types and the parameter types, that method is chosen.
? If there is no exact match, but there is a method with compatible parameter types, that method is chosen. Compatible types are those that can be converted from
one to another automatically, such as int to long or float to double.
? If there is more than one method with compatible parameter types, the most specific method is chosen. The most specific method is the one whose parameter
types are closest to the argument types in terms of size or precision.
In the code, the following method calls are made:
? test.sum(10, 10.5) -> This matches the sum(int a, float b) method exactly, so it is chosen. The result is 20.5, which is converted to int and printed as 20 (B).
? test.sum(10) -> This does not match any method exactly, but it matches the sum(double a) method with compatible types, as int can be converted to double
automatically. The result is 10.0, which is printed as 10 (A).
? test.sum(10.5, 10) -> This does not match any method exactly, but it matches two methods with compatible types: sum(float a, float b) and sum(double a, double
b). The latter is more specific, as double is closer to the argument types than float. The result is 20.5, which is printed as 20 (D).
Therefore, the output is B A D. References:
? Oracle Certified Professional: Java SE 17 Developer
? Java SE 17 Developer
? OCP Oracle Certified Professional Java SE 17 Developer Study Guide
? Method Overloading in Java
? Type conversion in Java with Examples
? Java Method Overloading with automatic type conversions

From SurePassExam
https://www.surepassexam.com/1z0-829-exam-dumps.html (50 New Questions)

Question 2

Given:

Accepted Answer

The code fragment will fail to compile because the parseInt method of the Integer class is a static method, which means that it can be invoked without creating an
object of the class. However, the code is trying to invoke the parseInt method on an object of type Integer, which is not allowed. The correct way to invoke the
parseInt method is by using the class name, such as Integer.parseInt (s). Therefore, the code fragment will produce a compilation error. References: Integer (Java
SE 17 & JDK 17) - Oracle

Question 3

Given the code fragment:
What is the result?

Accepted Answer

The code fragment uses the Collections.binarySearch method to search for the string ??e3?? in the list. The first search returns the index of the element, which is

From SurePassExam
https://www.surepassexam.com/1z0-829-exam-dumps.html (50 New Questions)
2. The second search returns the index of the element, which is 0. The third search returns the index of the element, which is -4. The final result is 2. References:
Collections (Java SE 17 & JDK 17) - Oracle

Question 4

Given the code fragment:

Accepted Answer

The code fragment compares four pairs of strings using the equals() and intern() methods. The equals() method compares the content of two strings, while the
intern() method returns a canonical representation of a string, which means that it returns a reference to an existing string with the same content in the string pool.
The string pool is a memory area where strings are stored and reused to save space and improve performance. The results of the comparisons are as follows:
? s1.equals(s2): This returns true because both s1 and s2 have the same content, ??Hello Java 17??.
? s1 == s2: This returns false because s1 and s2 are different objects with different references, even though they have the same content. The == operator
compares the references of two objects, not their content.
? s1.intern() == s2.intern(): This returns true because both s1.intern() and s2.intern() return a reference to the same string object in the string pool, which has the
content ??Hello Java 17??. The intern() method ensures that there is only one copy of each distinct string value in the string pool.
? ??Hello Java 17?? == s2: This returns false because ??Hello Java 17?? is a string literal, which is automatically interned and stored in the string pool, while s2 is
a string object created with the new operator, which is not interned by default and stored in the heap. Therefore, they have different references and are not equal
using the == operator.
References: String (Java SE 17 & JDK 17) - Oracle

Question 5

Given:
What is the result?

Accepted Answer

The code fragment is using the bitwise operators & (AND), | (OR), and ^ (XOR) to perform operations on the binary representations of the integer values. The &
operator returns a 1 in each bit position where both operands have a 1, the | operator returns a 1 in each bit position where either operand has a 1, and the ^
operator returns a 1 in each bit position where only one operand has a 1. The binary representations of the integer values are as follows:
? 1000 = 1111101000
? 100 = 1100100
? 101 = 1100101
The code fragment performs the following operations:
? x = x ^ y; // x becomes 1111010101, which is 1001 in decimal
? y = x ^ y; // y becomes 1100100, which is 100 in decimal
? x = x ^ y; // x becomes 1100101, which is 101 in decimal
The code fragment then prints out the values of x, y, and z, which are 1001, 100, and 1000 respectively. Therefore, option D is correct.

Question 6

Given:
and the code fragment:

Accepted Answer

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
References: Stream (Java SE 17 & JDK 17) - Oracle, Collectors (Java SE 17 & JDK 17) - Oracle

Question 7

Which two code fragments compile?
A)
B)
C)

From SurePassExam
https://www.surepassexam.com/1z0-829-exam-dumps.html (50 New Questions)
D)
E)

Accepted Answer

The two code fragments that compile are B and E. These are the only ones that use the correct syntax for declaring and initializing a var variable. The var
keyword is a reserved type name that allows the compiler to infer the type of the variable based on the initializer expression. However, the var variable must have
an initializer, and the initializer must not be null or a lambda expression. Therefore, option A is invalid because it does not have an initializer, option C is invalid
because it has a null initializer, and option D is invalid because it has a lambda expression as an initializer. Option B is valid because it has a String initializer, and
option E is valid because it has an int initializer. https://docs.oracle.com/en/java/javase/17/language/local-variable-type-inference.html

Question 8

Given:
What is the result?

Accepted Answer

The answer is E because the code fragment contains several syntax errors that prevent it from compiling. Some of the errors are:
? The enum declaration is missing a semicolon after the list of constants.
? The enum constants are not capitalized, which violates the Java naming convention for enums.
? The switch expression is missing parentheses around the variable name.
? The case labels are missing colons after the enum constants.
? The default label is missing a break statement, which causes a fall-through to the next case.
? The println statement is missing a closing parenthesis and a semicolon. A possible corrected version of the code fragment is:
enum Vehicle { BICYCLE, CAR, MOTORCYCLE, TRUCK; } public class Test { public static void main(String[] args) { Vehicle v = Vehicle.BICYCLE; switch (v) {
case BICYCLE:
System.out.print(??1??); break; case CAR: System.out.print(??3??); break; case MOTORCYCLE: System.out.print(??1??); break; case TRUCK:
System.out.print(??2??); break; default: System.out.print(??0??); break; } System.out.println(); } }
This would print 1 as the output. References:
? Oracle Certified Professional: Java SE 17 Developer
? Java SE 17 Developer
? OCP Oracle Certified Professional Java SE 17 Developer Study Guide
? Enum Types
? The switch Statement

Question 9

Given the code fragment:
Which code fragment invokes all callable objects in the workers set?
A)
B)
C)
D)

From SurePassExam
https://www.surepassexam.com/1z0-829-exam-dumps.html (50 New Questions)

Accepted Answer

The code fragment in Option C invokes all callable objects in the workers set by using the ExecutorService??s invokeAll() method. This method takes a collection
of Callable objects and returns a list of Future objects representing the results of the tasks. The other options are incorrect because they either use the wrong
method (invokeAny() or submit()) or have syntax errors (missing parentheses or
semicolons). References: AbstractExecutorService (Java SE 17 & JDK 17) - Oracle

Question 10

Given:
What is the result?

Accepted Answer

The code fragment will fail to compile because the play method in the Dog class is declared as private, which means that it cannot be accessed from outside the
class. The main method is trying to call the play method on a Dog object, which is not allowed. Therefore, the code fragment will produce a compilation error.