1z0-829 Exam Dumps - Oracle Certification Questions and Answers

The code fragment is using the stream methods allMatch, anyMatch, noneMatch, and findFirst on a list of strings called specialDays. These methods are used to perform matching operations on the elements of a stream, such as checking if all, any, or none of the elements satisfy a given predicate, or finding the first element that matches a predicate1. The predicate in this case is that the string equals “Labour” or “Halloween”. The output will be:

• False: because not all of the elements in specialDays are equal to “Labour” or “Halloween”.
• true: because at least one of the elements in specialDays is equal to “Labour” or “Halloween”.
• true: because none of the elements in specialDays are equal to both “Labour” and “Halloween”.
• Optional[NewYear]: because the first element in specialDays that matches the predicate is “NewYear”, and the findFirst method returns an Optional object that may or may not contain a non-null value2.

References: Stream (Java SE 17 & JDK 17), Optional (Java SE 17 & JDK 17)

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

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

The answer is D because the code fragment uses the Stream API to create two streams, s1 and s2, and then concatenates them using the concat() method. The resulting stream is then processed in parallel using the parallel() method, and the distinct() method is used to remove duplicate elements. Finally, the forEach() method is used to print the elements of the resulting stream to the console. Since the order of elements in a parallel stream is unpredictable, the output could be any of the options given, but option D is the most likely. References:

• Oracle Certified Professional: Java SE 17 Developer
• Java SE 17 Developer
• OCP Oracle Certified Professional Java SE 17 Developer Study Guide
• Parallelizing Streams

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

A module path is a sequence of directories that contain modules or JAR files. A named module is a module that has a name and a module descriptor (module-info.class) that declares its dependencies and exports. An automatic module is a module that does not have a module descriptor, but is derived from the name and contents of a JAR file. Both named and automatic modules can be placed on the module path, and they can be resolved by the Java runtime. An unnamed module is a special module that contains all the classes that are not in any other module, such as those on the class path. An unnamed module is not on the module path, but it can read all other modules.

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

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. References:

• Oracle Certified Professional: Java SE 17 Developer
• Java SE 17 Developer
• OCP Oracle Certified Professional Java SE 17 Developer Study Guide
• Java Methods

The answer is B because the code fragment contains a logical error that causes a MissingResourceException at runtime. The code fragment tries to load a resource bundle with the base name “Captions.properties” and the locale “en_US”. However, there is no such resource bundle available in the classpath. The available resource bundles are:

• Captions.properties
• Captions_en.properties
• Captions_US.properties
• Captions_en_US.properties

The ResourceBundle class follows a fallback mechanism to find the best matching resource bundle for a given locale. It first tries to find the resource bundle with the exact locale, then it tries to find the resource bundle with the same language and script, then it tries to find the resource bundle with the same language, and finally it tries to find the default resource bundle with no locale. If none of these resource bundles are found, it throws a MissingResourceException.

In this case, the code fragment is looking for a resource bundle with the base name “Captions.properties” and the locale “en_US”. The ResourceBundle class will try to find the following resource bundles in order:

• Captions.properties_en_US
• Captions.properties_en
• Captions.properties

However, none of these resource bundles exist in the classpath. Therefore, the ResourceBundle class will throw a MissingResourceException.

To fix this error, the code fragment should use the correct base name of the resource bundle family, which is “Captions” without the “.properties” extension. For example:

ResourceBundle captions = ResourceBundle.getBundle(“Captions”, currentLocale);

This will load the appropriate resource bundle for the current locale, which is “Captions_en_US.properties” in this case. References:

• Oracle Certified Professional: Java SE 17 Developer
• Java SE 17 Developer
• OCP Oracle Certified Professional Java SE 17 Developer Study Guide
• ResourceBundle (Java Platform SE 8 )
• About the ResourceBundle Class (The Java™ Tutorials > Internationalization)

The answer is D because the code fragment reads the content of the in.txt file and writes it to the out.txt file. The content of the in.txt file is “23456789”. The code fragment uses a char array buffer of size 8 to read the content of the in.txt file. The while loop reads the content of the in.txt file and writes it to the out.txt file until the end of the file is reached. Therefore, the content of the out.txt file will be “0123456789”.