Java 8 Streams

Question 1

Till Java 7 it provided abstraction such as inheritance and generics, what did these things abstract?

Answer 1

Abstraction over data

Question 2

Lambda expressions provide abstraction over what?

Answer 2

Abstraction over behavior

Question 3

Does lambda and streams make Java functional language?

Answer 3

No, functions are still not first class citizens in Java.

Question 4

What was main goal behind Java 8 lambda and streams?

Answer 4

The main goal was to make it easy, less error-prone to write parallel and concurrent code and utilize multiple cores available. At the same time improve readability of such code.

Question 5

By default till Java 7, for each loop was serial or parallel?

Answer 5

It was fixed as serial implementation. We couldn’t use multiple cores for iteration even if available. We had to write parallel code ourselves which is very hard to get right.

Question 6

Example where serial model is bottleneck

Answer 6

Suppose someone asked you to mail some letters with following instructions: If you have any more mails, take next one in alphabetical order of addressee’s surname and put it in mailbox. Obviously problem is overspecified. Ordering doesn’t matter in this task, neither does the mode serial or parallel.

Question 7

coll.forEach(Consumer), then Consumer is example of which GoF design pattern?

Answer 7

Command design pattern. Caller just knows what operation he needs to perform and iteration is done by foreach()

Question 8

Why were lambda expressions added?

Answer 8

• To make it less clumsy to add implementation of FunctionalInterfaces. Before that only way to do that was either create a dedicated class or create anonymous inner class.
• It reduced the verbosity, as rest of the things like method name of functional interfaces, interface name could be inferred by compiler.

Question 9

Stream allows us to view program in what way?

Answer 9

Data oriented way of looking at the program.

Question 10

What are stream and operators analogous to?

Answer 10

Unix pipes and filters

Question 11

What do streams represent?

Answer 11

Streams represent data in motion and don’t provide any way to store the data.

Question 12

Name Streams for primitives?

Answer 12

IntStream, LongStream, DoubleStream etc.

Question 13

Is stream eager or lazy?

Answer 13

Streams are lazy, all the intermidiate operators are lazy and the terminal operators like max, min, forEach() etc start pulling data from the source lazily.

Question 14

What can be sources of streams?

Answer 14

Collections, Arrays or Generating functions like IntStream.generate(..)

Question 15

What is recursive decomposition?

Answer 15

The process of splitting tasks into smaller ones to be executed in parallel, till they are “small enough” to be executed in serial. The technique for splitting depends on source of data.

Question 16

What fundamental principle does Fork Join pool in Java depend on?

Answer 16

Recursive decomposition.

Question 17

What is the way to telling java to use parallel execution to process the stream?

Answer 17

Source.parallelStream() is the way to tell java that parallel stream can be used which will utilize Fork/Join framework.

Question 18

Use of sorted operator and comparing, by example

Answer 18

intList.stream()
.map(i -> new Point(i % 3, i / 3))
.sorted(comparing(point -> p.distance(0, 0)))
.forEach(print);

Question 19

Which ordering does Comparator.comparing() return?

Answer 19

Natural ordering

Question 20

Comparator.comparing() method signature?

Answer 20

public static > Comparator comparing(Function keyExtracter)

Question 21

Is it allowed to provide explicit type in lambda parameters?

Answer 21

Yes it is allowed. But if type is provided for one it must be provided for all. And it is sometimes necessary to provide type information when the compiler cannot infer it from the context.
() -> 23
(x, y) -> x + y
(int x, int y) -> x + y

Question 22

Expression lambda vs statement lambda

Answer 22

Expression lambda can have only a single line and there is an explicit return, including for void. So for example x -> x * 3, i -> print(i), (x, y) -> x + y are expression lambdas.
Statement lambda are general where you can have curly braces block where you can write multiple lines of code. But that code needs to have explicit return statement.
For example (Thread t) -> {t.start();}, () -> {System.gc(); return 0; }

An expression lambda can be seen as args -> expr
A statement lambda can be seen as args -> {return expr;}

Question 23

Are lambda expressions allowed to declare exceptions they can throw using throws clause?

Answer 23

No, lambda expressions are neither required nor allowed to use throws clause to declare the exceptions they can throw.

Question 24

Lambda vs anonymous inner class

Answer 24

1 - An inner class creation expression is guaranteed to create a new object with unique identity but that is not true for lambda expression. It is implementation dependent.
2 - An inner class declaration creates new naming scope where this and super refer to current inner class. By contrast lambda expressions do not introduce any naming environment. So using this in lambda refers to enclosing class in which lambda is defined.

Question 25

Can lambda expressions have state?

Answer 25

No. Lambda expressions are not allowed to have state. So their identity does not matter. This allows platform flexibility to optimize in ways which would not be possible if all lambda expressions were required to have unique identity.

Question 26

Can a lambda refer to itself?

Answer 26

We cannot use this to refer to lambda, but a lambda can refer to itself if its name is in the scope but there are few restrictions. It is still possible to declare recursive lambda

class Factorial {
  IntUnaryOperator fact;
  public Factorial() {
    fact = i -> i == 0 ? 1 : i * fact.applyAsInt(i - 1);
  }
}

Question 27

Can lambda parameters and lambda body local declarations shadow field names?

Answer 27

Yes a field name can be temporarily redeclared as a parameter or local variable name

class Foo {
  Object i, j;
  IntUnaryOperator iuo = i -> { int j = 3; return i + j;}
}

Question 28

Is it possible to redeclare a local variable in lambda?

Answer 28

No, it is illegal to redeclare a local variable within a lambda

void foo() {
  final int i = 2;
  Runnable r = () -> {int i = 3; }} // illegal
}

Question 29

What is a non-capturing lambda?

Answer 29

A lambda which interact with environment only via arguments and return values are stateless or non-capturing.

Question 30

What is a capturing lambda?

Answer 30

Capture is a technical term for the retention by a lambda of a reference to its environment. The connotation is that the variable has been ensnared by the lambda and held, to be queried or in other lamguages - modified, when the lambda is later evaluated.

Question 31

Can a lambda change the captured variable?

Answer 31

No, the capture provided is restricted; the central principle of the restriction is that captured variables may not have their values changed.

Question 32

Anonymous class variable capture vs Lambda variable capture?

Answer 32

In case of Anonymous class we needed to make the variable final, but in case of Lambda, there is no need to explicitly mark it as final. It should be effectively final.