8. Lambda Expressions and Functional Interfaces

Question 1

What does the flatmap expects?

Answer 1

The flatmap expects a function that will take on element and create a Stream out of it

Question 2

What does the mapToDouble method expects?

Answer 2

The mapToDouble method expects a ToDoubleFunction object. that will take an argument and return a double

Question 3

Consumer

Answer 3

Represents an operation that accepts a single input argument and returns no result

public interface Consumer{
    void accept(T t);
}

Consumer consumer = s -> System.out.println(s);

Question 4

Supplier

Answer 4

Represents an operation that does not take any argument and returns any kind of object aslong as it matches the type.

public interface Supplier{
    T get();
}

Supplier supplier =
() -> “Hello!;

Question 5

Function

Answer 5

represents an operation that takes any object and may return any kind of object of another type.

public interface Function{
R apply(T t);
}

Function getName =
user -> user.getName();

Question 6

Predicate

Answer 6

represents an operation that takes any kind of object, test it and returns a boolean

public interface Predicate{
    boolean test(T t);
}

Predicate isEmpty =
s -> s.isEmpty();

Question 7

What does the forEach method expects?

Answer 7

The forEach() method expects a consumer as an argument

Question 8

What does the map’s forEach method expects?

Answer 8

The map’s forEach method requires a bifurcation, a function that takes two arguments

Question 9

Do you need parentheses by the parameters in a lambda?

Answer 9

you can leave off the parantheses around the parameter, however if you have
more than one parameter you must use the parentheses.

Question 10

do you need curly braces when returning an expression?

Answer 10

If you try to return a single expression without curly braces, your lambda expression won’t compile. But you can use it only in curly braces.

Question 11

Can you acces variables of the enclosing scope?

Answer 11

A lambda expression captures variables from the ecnlosing scope, so you can access those variables in the body of the lambda, but those variables must be final or effectively final. An effectively final variable is a variable or parameter whose value isn’t changed after it is initialized. You can’t modify the values of an variable in the lambda expression, otherwise you get an error.

Question 12

What does the @FuncionalInterface do?

Answer 12

We can explicity define a functional interface using the @FunctionalInterface annotation. This
annotation is not required but can be helpful when you want to ensure you don’t inadvertently add methods to a functional interface that will then break other code.

Question 13

What are the 4 basic types of functional interfaces?

Answer 13

Supplier, Consumer, Predicate and Function

Question 14

What are the variations on supplier?

Answer 14

IntSupplier, DoubleSupplier, LongSupplier. The functional method names of each of
these is different and is not get(), the funtional method of IntSupplier is getAsInt().

Question 15

What are the variations on consumer?

Answer 15

IntConsumer, DoubleConsumer, LongConsumer, their

accept() methods take one primitive argument and avoid the autoboxing you get with consumer.

Question 16

what are variations on the primitive consumers?

Answer 16

there is ObjIntConsumer, ObjDoubleConsumer, ObjLongConsumer, whose
accept() methods take an object (type t) and a int , a double or a long.

Question 17

What is a BiConsumer?

Answer 17

BiConsumer, its accept() method takes two object (types T and U, meaning the two objects don’t
have to be of the same type).

Question 18

What do you need to remember with Lambdas?

Answer 18

you can’t modify a variable within the lambda, otherwise you will get a compiler error.
And outside the a lambda expression the variables must be final or effectively final.

Question 19

Can we modify a field of an object?

Answer 19

If we want to use forEach() to iterate through a collection of objects to, we can’t return the value we find (because forEach() takes a consumer and the accept() of a consumer method is void), but we can change the field of an object from within the lambda to do the same thing.

Question 20

What does the andThen() method do?

Answer 20

andThen() is actually a default method of the Consumer interface that you can use to chain
consumers together. Notice that the type of the consumer you pass to the
andThen() method must match the type of the consumer used as the first operation.

Question 21

What default methods does the predicate interface have?

Answer 21

The default methods:

and(), or(), and negate(), are there so you can chain predicates together

Question 22

What are the variations on predicate?

Answer 22

BiPredicate, DoublePredicate, IntPredicate, LongPredicate. BiPredicate’s test takes arguments and the others take one argument of a primitive type (to avoid
autoboxing).

Question 23

What does the UnaryOperator do?

Answer 23

The one operator you should be familiar with for the exam is the UnaryOperator. It extends Function, so its functional method is also apply(). However it requires that the type of the argument to apply() be the same as the type of the return value.

Question 24

What is method reference?

Answer 24

You can create method references for your own methods, too:

Trees.forEach(::);