Free 1Z0-809 Practice Test

The ExecutorService is given a Callable task via submit. The main thread then calls f1.get(), which blocks until the task completes. The task itself first executes System.out.print("Java EE"). After this, it completes by returning the string "Java SE". The f1.get() call receives this return value, which the main thread then prints. Because get() waits for the task, "Java EE" is always printed before the returned "Java SE" is printed.

A. Java EEJava EESE: The task returns "Java SE", not "SE", and "Java EE" is printed only once by the task.
B. Java EESE: The task returns the full string "Java SE", not just "SE".
C. The program prints either:Java EEJava SEorJava SEJava EE: The Future.get() call is blocking, which establishes a happens-before relationship. The task's actions must complete before get() returns, so the order is fixed.

1. Oracle Corporation. (2018). Interface Future. Java™ Platform, Standard Edition 8 API Specification. "The get() method waits if necessary for the computation to complete, and then retrieves its result."

2. Oracle Corporation. (2018). Interface Callable. Java™ Platform, Standard Edition 8 API Specification. "A task that returns a result and may throw an exception."

3. Goetz, B., et al. (2006). Java Concurrency in Practice. Addison-Wesley. Chapter 6, Task Execution, discusses the behavior of ExecutorService and Future.

The code will fail to compile for two primary reasons. First, the method reference Student::getCourse requires a public method named getCourse() to be present in the Student class, which is missing. The Student class only defines public fields. Second, the lambda expression in the forEach call, (src, res) -> System.out.println(scr)), contains a typo. The variable scr is not defined; the parameter name is src. Either of these issues is sufficient to cause a compilation error.

A. The code will not compile, so it cannot produce this output. This output format also does not match what a Map.forEach printing only the key would produce.
B. The code will not compile. Even if it did, printing just the keys "Java EE" and "Java ME" would require a different lambda, such as (src, res) -> System.out.print(src).
C. The code will not compile. This output is similar to A but in a different, non-guaranteed order, and is also incorrect for the same reasons.

1. Oracle, The Java™ Tutorials, "Method References". (docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html). This tutorial explains that method references are compact lambda expressions for methods that already have a name. The syntax ClassName::methodName requires methodName to be a method.

2. The Java® Language Specification, Java SE 8 Edition, Section 15.13, "Method Reference Expressions". This section formally defines the syntax and semantics of method references, which apply to methods and constructors, not fields.

3. The Java® Language Specification, Java SE 8 Edition, Section 15.27.1, "Lambda Parameters". This section defines the scope of lambda parameters, confirming that a variable like scr would be an "unresolved symbol" if not declared as a parameter.

The goal is to execute the run methods of both Worker and Master. A CyclicBarrier can be configured with a barrierAction (a Runnable) that executes when the barrier is tripped. By setting the number of parties to 1 (new CyclicBarrier(1, master)), the barrier will trip as soon as the single Worker thread calls cb.await(). This immediately triggers the master Runnable to execute its run method. After the barrier action completes, the Worker thread is unblocked and proceeds to execute the rest of its run method, printing "Worker...".

A. A CyclicBarrier with 2 parties will cause the Worker thread to wait indefinitely because only one thread (worker) calls await(), and the barrier is never tripped.
B. Changing Master to extend Thread does not cause its run method to be executed, as no Master thread is ever started with .start().
D. The CyclicBarrier class does not have a constructor that accepts only a Runnable argument. This line would result in a compilation error.

1. Oracle, "Java SE 8 API Specification, java.util.concurrent.CyclicBarrier," docs.oracle.com. The constructor CyclicBarrier(int parties, Runnable barrierAction) is documented, which creates a new CyclicBarrier that will trip when the given number of parties (parties) are waiting upon it, and which will execute the given barrier action when the barrier is tripped.

2. Goetz, B., et al. (2006). Java Concurrency in Practice. Addison-Wesley Professional. Chapter 5.4, "Barriers," explains the mechanics of CyclicBarrier, including the barrier action.

The Files.lines(Path) method reads all lines from a file and returns them as a Stream. This is the most direct and idiomatic way in Java 8 to process a file's content line-by-line using the Stream API. The returned stream can then be consumed by a terminal operation like forEach to print each line. This approach is also memory-efficient for large files as it reads lines lazily.

A. Files.list() is used for listing the contents of a directory, not for reading a file. It would throw a NotDirectoryException at runtime.
B. Files.readAllLines() returns a List, not a Stream. Assigning its result to a Stream variable causes a compilation error.
C. The method call readAllLines(file) is a compilation error. The correct call is Files.readAllLines(file), as it is a static method of the Files class.

- Java SE 8 Platform API Specification, java.nio.file.Files.lines(Path path). The documentation confirms it returns a Stream with the lines from a file.

- Oracle, The Java™ Tutorials, "Reading, Writing, and Creating Files". This tutorial presents Files.lines as the standard method for reading a text file as a stream of lines.

The Files.move() method attempts to move the source file to the target path. The question states that the target file, /colors/yellow.txt, already exists. When the target file exists and the REPLACEEXISTING copy option is NOT specified, the move operation fails. Consequently, the Java NIO API throws a FileAlreadyExistsException to indicate this condition. The subsequent Files.delete(source) line is never reached because the exception interrupts the normal execution flow.

A. No file content is replaced. The move operation fails before any modification can occur because the target file already exists.
B. The move operation fails by throwing an exception immediately upon discovering the existing target file; no content is replaced first.
C. The file is not moved. The operation is aborted due to the pre-existing target file, and an exception is thrown.

1. Oracle, "Java SE 8 API Documentation, java.nio.file.Files class, move(Path, Path, CopyOption...) method". The documentation states: "If the target file exists then it is implementation specific if the existing file is replaced or this method fails by throwing an IOException... If the options array contains the REPLACEEXISTING option, then the target file is replaced if it exists." Without this option, the standard behavior is to throw FileAlreadyExistsException.

2. Oracle, "Java SE 8 API Documentation, java.nio.file.FileAlreadyExistsException class". This exception is "Checked exception thrown when an attempt is made to create a file or directory in a location where a file of that name already exists."

The stream pipeline first filters the empDetails list. The filter(s-> s.contains("1")) operation retains elements that contain the character "1", which are "100, Robin, HR" and "101, Peter, HR". The sorted() operation then sorts these two remaining strings in their natural (lexicographical) order, which they are already in. Finally, forEach(System.out::println) iterates through the sorted stream and prints each element on a new line. The resulting sequence of printed strings is "100, Robin, HR" followed by "101, Peter, HR".

B. The code is syntactically valid. Stream operations are correctly chained, and the method reference is appropriate for forEach.
C. The string "200, Mary, AdminServices" is incorrectly included; it should be removed by the filter operation as it does not contain "1".
D. The order is incorrect. The sorted() method guarantees a natural lexicographical sort, placing "100..." before "101...".

- Oracle, Java SE 8 Documentation, java.util.stream.Stream. The documentation for filter(Predicate predicate) and sorted() describes their behavior.

- Oracle, The Java™ Tutorials, "Lesson: Aggregate Operations". This tutorial explains the behavior of intermediate operations like filter and sorted.

The findFirst() operation is a short-circuiting terminal operation. The stream processing stops as soon as the first element matching the predicate is found. The predicate test is a lambda expression where the variable i is declared locally. Therefore, i is re-initialized to 0 every time the predicate is invoked.
1. test("my") is called. It prints "0:" and returns false.
2. test("pen") is called. It prints "0:" and returns true. The stream pipeline finds its first match ("pen") and terminates. The ifPresent consumer then prints "pen". The final output is "0:0:pen".

B. The variable i is local to the lambda, so it is reset to 0 on each call and never prints 1.
C. The findFirst() operation is short-circuiting, so the stream does not process all elements after a match is found.
D. The stream is short-circuited, and the local variable i does not persist its value across predicate calls.
E. The code is syntactically correct. A lambda expression can contain multiple statements enclosed in braces.

- Oracle, The Java™ Tutorials, "Aggregate Operations > Short-Circuiting". This section explains that operations like findFirst can terminate processing early.

- Oracle, Java SE 8 Documentation, java.util.stream.Stream#findFirst(). The documentation describes findFirst() as a short-circuiting terminal operation.

- Java Language Specification, SE 8 Edition, §15.27.2. "Lambda Body". This section details that variables declared within a lambda body are local to it.

Interfaces are used to define a contract that unrelated classes can implement. This allows objects of different class hierarchies to be treated polymorphically based on the shared interface. For example, String and Integer are unrelated but both implement Comparable. Additionally, a class can implement multiple interfaces, which allows it to inherit multiple types, a form of multiple inheritance that is not possible with classes. Abstract classes are better suited for sharing code and state among closely related classes within a single inheritance hierarchy.

A. This describes a use case for abstract classes, which can have fields, non-public methods, and shared implementation code.
C. This is the primary purpose of an abstract class, which serves as a base for a hierarchy of related classes.
D. Interfaces can only declare public static final fields. Abstract classes can declare non-static and non-final fields.

1. Oracle, The Java™ Tutorials. "Abstract Methods and Classes". "Consider using abstract classes if... You want to share code among several closely related classes."

2. Oracle, The Java™ Tutorials. "Interfaces". "Consider using interfaces if... You expect that unrelated classes would implement your interface... You want to take advantage of multiple inheritance of type."

3. The Java™ Language Specification, Java SE 8 Edition, §9.1. "An interface declaration introduces a new reference type... A class can implement more than one interface."

The Moveable interface is a functional interface because it declares exactly one abstract method, run. Therefore, it can be a target for a lambda expression. Option A correctly provides a lambda expression n -> System.out.println("Running" + n) for the run method. The code then correctly calls the implemented run method and the inherited default walk method on the instance animal. The use of a raw type Moveable is valid, though it may generate a compiler warning.

B: The lambda n -> n + 10 has a return value, which is incompatible with the run method's void return type, causing a compilation error. C: The call Moveable.walk(20) is invalid. walk is a default (instance) method, not a static method, and must be invoked on an object instance (e.g., animal.walk(20)). D: This is incorrect. An interface with a single abstract method is a functional interface and can be implemented using a lambda expression.

- The Java™ Language Specification, Java SE 8 Edition, Section 9.8, "Functional Interfaces". It states, "A functional interface is an interface that has just one abstract method (aside from the methods of Object)".

- The Java™ Tutorials, "Lambda Expressions". Oracle Corporation. This tutorial explains that a lambda expression can be used to represent an instance of a functional interface.

- The Java™ Language Specification, Java SE 8 Edition, Section 9.4.1, "Default Methods". It clarifies that default methods are instance methods.

This question tests the concept of late-binding in Java Streams. A stream pipeline is built but not executed until a terminal operation is invoked. The code likely creates a stream from a list (e.g., List list = new ArrayList(Arrays.asList(3, 5, 6)); Stream s = list.stream();). Before the terminal operation on the stream s is called, the underlying list list is modified so that all its elements become 4. When the terminal operation finally executes, it traverses the source, which is the now-modified list. Therefore, the stream processes the elements [4, 4, 4], leading to the output 4 : 4 : 4.

A. This output 5 : 3 : 6 does not correspond to a logical modification of the initial list [3, 5, 6] before stream processing.
B. This output 6 : 5 : 6 does not correspond to a logical modification of the initial list [3, 5, 6] before stream processing.
C. This output 3 : 3 : 4 does not correspond to a logical modification of the initial list [3, 5, 6] before stream processing.

1. Oracle. "The Java™ Tutorials - Aggregate Operations". The section on "Laziness" explains that intermediate operations are not executed until a terminal operation is invoked.

2. Oracle. "Package java.util.stream". The package documentation notes: "For a stream to behave correctly, the stream source should not be modified during the stream pipeline's execution." This implies modifications before execution can affect the result.