StreamQuiz

What could be the output of the following?

• 12112

• 1. 212

• 1. 212112

• java.util.stream.ReferencePipeline$3@4517d9a3

• 1. The code does not compile.

Answer explanation

1. D.  No terminal operation is called, so the stream never executes. The first line creates an infinite stream reference. If the stream were executed on the second line, it would get the first two elements from that infinite stream, "" and "1", and add an extra character, resulting in "2" and "12", respectively. Since the stream is not executed, the reference is printed instead, giving us option D.

What could be the output of the following?

• 1. true false

• 1. true true

• 1. java.util.stream.ReferencePipeline$3@4517d9a3

• 1. An exception is thrown.

• 1. The code hangs.

Answer explanation

1. F.  Both streams created in this code snippet are infinite streams. The variable b1 is set to true since anyMatch() terminates. Even though the stream is infinite, Java finds a match on the first element and stops looking. However, when allMatch() runs, it needs to keep going until the end of the stream since it keeps finding matches. Since all elements continue to match, the program hangs, making option F the answer.

What could be the output of the following?

• 1. false false

• 1. An exception is thrown

• 1. java.util.stream.ReferencePipeline$3@4517d9a3

• 1. The code does not compile.

• 1. The code hangs.

Answer explanation

1. E.  An infinite stream is generated where each element is twice as long as the previous one. While this code uses the three-parameter iterate() method, the condition is never false. The variable b1 is set to false because Java finds an element that matches when it gets to the element of length 4. However, the next line tries to operate on the same stream. Since streams can be used only once, this throws an exception that the “stream has already been operated upon or closed” and making option E the answer. If two different streams were used, the result would be option B.

1. Which are true statements about terminal operations in a stream that runs successfully? (Choose all that apply.)

2. 1. A.- At most one terminal operation can exist in a stream pipeline.

   2. B.- Terminal operations are a required part of the stream pipeline in order to get a result.

   3. C.- Terminal operations have Stream as the return type.

   4. D.- The peek() method is an example of a terminal operation.

   5. E.- The referenced Stream may be used after calling a terminal operation.

• A

• B

• C

• D

• E

Answer explanation

1. A, B.  Terminal operations are the final step in a stream pipeline. Exactly one is required, because it triggers the execution of the entire stream pipeline. Therefore, options A and B are correct. Option C is true of intermediate operations rather than terminal operations. Option D is incorrect because peek() is an intermediate operation. Finally, option E is incorrect because once a stream pipeline is run, the Stream is marked invalid.

Which of the following sets result to 8.0? (Choose all that apply.)

• 
• 
• 
• 
• 

Answer explanation

1. C, F.  Yes, we know this question is a lot of reading. Remember to look for the differences between options rather than studying each line. These options all have much in common. All of them start out with a LongStream and attempt to convert it to an IntStream. However, options B and E are incorrect because they do not cast the long to an int, resulting in a compiler error on the mapToInt() calls.

   Next, we hit the second difference. Options A and D are incorrect because they are missing boxed() before the collect() call. Since groupingBy() is creating a Collection, we need a nonprimitive Stream. The final difference is that option F specifies the type of Collection. This is allowed, though, meaning both options C and F are correct.

Which of the following can fill in the blank so that the code prints out false? (Choose all that apply.)

• 1. allMatch

• 1. anyMatch

• 1. findAny

• 1. findFirst

• 1. noneMatch

Answer explanation

1. A.  Options C and D do not compile because these methods do not take a Predicate parameter and do not return a boolean. When working with streams, it is important to remember the behavior of the underlying functional interfaces. Options B and E are incorrect. While the code compiles, it runs infinitely. The stream has no way to know that a match won't show up later. Option A is correct because it is safe to return false as soon as one element passes through the stream that doesn't match.

We have a method that returns a sorted list without changing the original. Which of the following can replace the method implementation to do the same with streams?

• 
• 
• 
• 
• 

Answer explanation

1. F.  There is no Stream<T> method called compare() or compareTo(), so options A through D can be eliminated. The sorted() method is correct to use in a stream pipeline to return a sorted Stream. The collect() method can be used to turn the stream into a List. The collect() method requires a collector be selected, making option E incorrect and option F correct.

Which of the following are true given this declaration? (Choose all that apply.)

• 1. is.average() returns the type int.

• 1. is.average() returns the type OptionalInt.

• 1. is.findAny() returns the type int.

• 1. is.findAny() returns the type OptionalInt.

• 1. is.sum() returns the type int.

Answer explanation

1. D, E.  The average() method returns an OptionalDouble since averages of any type can result in a fraction. Therefore, options A and B are both incorrect. The findAny() method returns an OptionalInt because there might not be any elements to find. Therefore, option D is correct. The sum() method returns an int rather than an OptionalInt because the sum of an empty list is zero. Therefore, option E is correct.

Which of the following can we add after line 6 for the code to run without error and not produce any output? (Choose all that apply.)

• if (opt.isPresent()) System.out.println(opt.get());

• if (opt.isPresent()) System.out.println(opt.getAsLong());

• 1. opt.ifPresent(System.out::println);

• 1. None of these; the code does not compile.

• 1. None of these; line 6 throws an exception at runtime.

Answer explanation

1. B, D.  Lines 4–6 compile and run without issue, making option F incorrect. Line 4 creates a stream of elements [1, 2, 3]. Line 5 maps the stream to a new stream with values [10, 20, 30]. Line 6 filters out all items not less than 5, which in this case results in an empty stream. For this reason, findFirst() returns an empty Optional.

   Option A does not compile. It would work for a Stream<T> object, but we have a LongStream and therefore need to call getAsLong(). Option C also does not compile, as it is missing the :: that would make it a method reference. Options B and D both compile and run without error, although neither produces any output at runtime since the stream is empty.

Given the four statements (L, M, N, O), select and order the ones that would complete the expression and cause the code to output 10 lines. (Choose all that apply.)

• 1. L, N, M

• 1. L, N, M, O

• 1. L, O, M

• 1. N, M

• 1. N, O

Answer explanation

1. F.  Only one of the method calls, forEach(), is a terminal operation, so any answer in which M is not the last line will not execute the pipeline. This eliminates all but options C, E, and F. Option C is incorrect because filter() is called before limit(). Since none of the elements of the stream meets the requirement for the Predicate<String>, the filter() operation will run infinitely, never passing any elements to limit(). Option E is incorrect because there is no limit() operation, which means that the code would run infinitely. Only option F is correct. It first limits the infinite stream to a finite stream of ten elements and then prints the result.