Joao Carlos Sousa do Vale

Posted on May 13, 2022

Functional Programming - What you need to know

#programming #java #certification #tutorial

Functional Programming

Introduction

focusing on the Streams API.
a functional interface has exactly one abstract method.
- java.util.function package.

Functional interface	Return type	Method name	# of parameters
Supplier	T	get()	0
Consumer	void	accept(T)	1
BiConsumer	void	accept(T,U)	2 (T, U)
Predicate	boolean	test(T)	1 (T)
BiPredicate	boolean	test(T,U)	2 (T, U)
Function	R	apply(T)	1 (T)
BiFunction	R	apply(T,U)	2 (T, U)
UnaryOperator	T	apply(T)	1 (T)
BinaryOperator	T	apply(T,T)	2 (T, T)

IMPLEMENTING SUPPLIER

A Supplier is used when you want to generate or supply values without taking any input.
- is often used when constructing new objects.

@FunctionalInterface
public interface Supplier<T> {
   T get();
}

Supplier<LocalDate> s1 = () -> LocalDate.now();

LocalDate d1 = s1.get();

System.out.println(d1);

IMPLEMENTING CONSUMER AND BICONSUMER

You use a Consumer when you want to do something with a parameter but not return anything.
BiConsumer does the same thing except that it takes two parameters.

@FunctionalInterface
public interface Consumer<T> {
   void accept(T t);
}

@FunctionalInterface
public interface BiConsumer<T, U> {
   void accept(T t, U u);
}

Consumer<String> c1 = x -> System.out.println(x);

c1.accept("Annie");

var map = new HashMap<String, Integer>();
BiConsumer<String, Integer> b1 = (k, v) -> map.put(k, v);

b1.accept("chicken", 7);
b1.accept("chick", 1);

System.out.println(map);

IMPLEMENTING PREDICATE AND BIPREDICATE

Predicate is often used when filtering or matching.
A BiPredicate is just like a Predicate except that it takes two parameters instead of one.

@FunctionalInterface
public interface Predicate<T> {
   boolean test(T t);
}

@FunctionalInterface
public interface BiPredicate<T, U> {
   boolean test(T t, U u);
}

Predicate<String> p1 = x -> x.isEmpty();

System.out.println(p1.test(""));  // true

BiPredicate<String, String> b1 = (string, prefix) -> string.startsWith(prefix);

System.out.println(b1.test("chicken", "chick"));  // true

IMPLEMENTING FUNCTION AND BIFUNCTION

A Function is responsible for turning one parameter into a value of a potentially different type and returning it.
a BiFunction is responsible for turning two parameters into a value and returning it.

@FunctionalInterface
public interface Function<T, R> {
   R apply(T t);
}

@FunctionalInterface
public interface BiFunction<T, U, R> {
   R apply(T t, U u);
}

Function<String, Integer> f1 = x -> x.length();

System.out.println(f1.apply("cluck")); // 5

BiFunction<String, String, String> b1 = (string, toAdd) -> string.concat(toAdd);

System.out.println(b1.apply("baby ", "chick")); // baby chick

IMPLEMENTING UNARYOPERATOR AND BINARYOPERATOR

UnaryOperator and BinaryOperator require all type parameters to be the same type.
A UnaryOperator transforms its value into one of the same type.
A BinaryOperator merges two values into one of the same type.

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
  T apply(T t);
}

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
  T apply(T t1, T t2);
}

UnaryOperator<String> u1 = x -> x.toUpperCase();

System.out.println(u1.apply("chirp"));  // CHIRP

BinaryOperator<String> b1 = (string, toAdd) -> string.concat(toAdd);

System.out.println(b1.apply("baby ", "chick")); // baby chick

CONVENIENCE METHODS ON FUNCTIONAL INTERFACES

Several of the common functional interfaces provide a number of helpful default methods.

Interface instance	Method return type	Method name	Method parameters
Consumer	Consumer	andThen()	Consumer
Function	Function	andThen()	Function
Function	Function	compose()	Function
Predicate	Predicate	and()	Predicate
Predicate	Predicate	negate()	—
Predicate	Predicate	or()	Predicate

Predicate<String> egg = s -> s.contains("egg");
Predicate<String> brown = s -> s.contains("brown");

Predicate<String> brownEggs = egg.and(brown);
Predicate<String> otherEggs = egg.and(brown.negate());

Consumer<String> c1 = x -> System.out.print("1: " + x);
Consumer<String> c2 = x -> System.out.print(",2: " + x);

Consumer<String> combined = c1.andThen(c2);
combined.accept("Annie");              // 1: Annie,2: Annie

Function<Integer, Integer> before = x -> x + 1;
Function<Integer, Integer> after = x -> x * 2;

Function<Integer, Integer> combined = after.compose(before);
System.out.println(combined.apply(3));   // 8

Optional

An Optional is created using a factory.
- Think of an Optional as a box that might have something in it or might instead be empty

Optional.empty()
Optional.of(<value>)

CREATING AN OPTIONAL

10: public static Optional<Double> average(int… scores) {
11:    if (scores.length == 0) return Optional.empty();
12:    int sum = 0;
13:    for (int score: scores) sum += score;
14:    return Optional.of((double) sum / scores.length);
15: }

...

      System.out.println(average(90, 100)); // Optional[95.0]
      System.out.println(average());        // Optional.empty

...

20: Optional<Double> opt = average(90, 100);
21: if (opt.isPresent())
22:    System.out.println(opt.get()); // 95.0

We'd get an exception since there is no value inside the Optional.
- java.util.NoSuchElementException: No value present

26: Optional<Double> opt = average();
27: System.out.println(opt.get()); // NoSuchElementException

it is common to want to use empty() when the value is null.
- You can do this with an if statement or ternary operator ( ? :) .

Optional o = (value == null) ? Optional.empty() : Optional.of(value);

Optional o = Optional.ofNullable(value);

Method	When Optional is empty	When Optional contains a value
get()	Throws an exception	Returns value
ifPresent(Consumer c)	Does nothing	Calls Consumer with value
isPresent()	Returns false	Returns true
orElse(T other)	Returns other parameter	Returns value
orElseGet(Supplier s)	Returns result of calling Supplier	Returns value
orElseThrow()	Throws NoSuchElementException	Returns value
orElseThrow(Supplier s)	Throws exception created by calling Supplier	Returns value

ifPresent() -> You can think of it as an if statement with no else.

Optional<Double> opt = average(90, 100);
opt.ifPresent(System.out::println);

DEALING WITH AN EMPTY OPTIONAL

30: Optional<Double> opt = average();
31: System.out.println(opt.orElse(Double.NaN));
32: System.out.println(opt.orElseGet(() -> Math.random()));

NaN
0.49775932295380165

30: Optional<Double> opt = average();
31: System.out.println(opt.orElseThrow());

Without specifying a Supplier for the exception, Java will throw a NoSuchElementException.

Exception in thread "main" java.util.NoSuchElementException: 
   No value present
   at java.base/java.util.Optional.orElseThrow(Optional.java:382)

30: Optional<Double> opt = average();
31: System.out.println(opt.orElseThrow(
32:    () -> new IllegalStateException()));

Exception in thread "main" java.lang.IllegalStateException
   at optionals.Methods.lambda$orElse$1(Methods.java:30)
   at java.base/java.util.Optional.orElseThrow(Optional.java:408)

Using Streams

A stream in Java is a sequence of data.
A stream pipeline consists of the operations that run on a stream to produce a result.

UNDERSTANDING THE PIPELINE FLOW

stream pipeline as an assembly line in a factory.
- stream operations
There are three parts to a stream pipeline
- source: Where the stream comes from
- intermediate operations: Transforms the stream into another one.
- terminal operation: Actually produces a result.
The stream is no longer valid after a terminal operation completes.

CREATING STREAM SOURCES

In Java, the streams are represented by the Stream interface, defined in the java.util.stream package.

Creating Finite Streams

11: Stream<String> empty = Stream.empty();          // count = 0
12: Stream<Integer> singleElement = Stream.of(1);   // count = 1
13: Stream<Integer> fromArray = Stream.of(1, 2, 3); // count = 3
14: var list = List.of("a", "b", "c");
15: Stream<String> fromList = list.stream();

Creating Infinite Streams

7: Stream<Double> randoms = Stream.generate(Math::random);
18: Stream<Integer> oddNumbers = Stream.iterate(1, n -> n + 2);

overloaded example of iterate()

19: Stream<Integer> oddNumberUnder100 = Stream.iterate(
20:    1,                // seed
21:    n -> n < 100,     // Predicate to specify when done
22:    n -> n + 2);      // UnaryOperator to get next value

Method	Finite or infinite?	Notes
Stream.empty()	Finite	Creates Stream with zero elements
Stream.of(varargs)	Finite	Creates Stream with elements listed
coll.stream()	Finite	Creates Stream from a Collection
coll.parallelStream()	Finite	Creates Stream from a Collection where the stream can run in parallel
Stream.generate(supplier)	Infinite	Creates Stream by calling the Supplier for each element upon request
Stream.iterate(seed, unaryOperator)	Infinite	Creates Stream by using the seed for the first element and then calling the UnaryOperator for each subsequent element upon request
Stream.iterate(seed, predicate, unaryOperator)	Finite or infinite	Creates Stream by using the seed for the first element and then calling the UnaryOperator for each subsequent element upon request. Stops if the Predicate returns false

USING COMMON TERMINAL OPERATIONS

You can perform a terminal operation without any intermediate operations but not the other way around.
Reductions are a special type of terminal operation where all the contents of the stream are combined into a single primitive or Object.

Method	What happens for infinite streams	Return value	Reduction
count()	Does not terminate	long	Yes
min() max()	Does not terminate	Optional	Yes
findAny() findFirst()	Terminates	Optional	No
allMatch() anyMatch() noneMatch()	Sometimes terminates	boolean	No
forEach()	Does not terminate	void	No
reduce()	Does not terminate	Varies	Yes
collect()	Does not terminate	Varies	Yes

count()

The count() method determines the number of elements in a finite stream.

long count()

Stream<String> s = Stream.of("monkey", "gorilla", "bonobo");
System.out.println(s.count());   // 3

min() and max()

The min() and max() methods allow you to pass a custom comparator and find the smallest or largest value in a finite stream according to that sort order.

Optional<T> min(Comparator<? super T> comparator)
Optional<T> max(Comparator<? super T> comparator)

Stream<String> s = Stream.of("monkey", "ape", "bonobo");
Optional<String> min = s.min((s1, s2) -> s1.length()-s2.length());
min.ifPresent(System.out::println); // ape

Returns an optional because we have cases where is not possible to find a min or max.

Optional<?> minEmpty = Stream.empty().min((s1, s2) -> 0);
System.out.println(minEmpty.isPresent()); // false

findAny() and findFirst()

The findAny() and findFirst() methods return an element of the stream unless the stream is empty.
- If the stream is empty, they return an empty Optional.
can terminate with an infinite stream.

Optional<T> findAny()
Optional<T> findFirst()

Stream<String> s = Stream.of("monkey", "gorilla", "bonobo");
Stream<String> infinite = Stream.generate(() -> "chimp");

s.findAny().ifPresent(System.out::println);        // monkey (usually)
infinite.findAny().ifPresent(System.out::println); // chimp

allMatch(), anyMatch(), and noneMatch()

The allMatch(), anyMatch(), and noneMatch() methods search a stream and return information about how the stream pertains to the predicate.
These may or may not terminate for infinite streams.
they are not reductions because they do not necessarily look at all of the elements.

boolean anyMatch(Predicate <? super T> predicate)
boolean allMatch(Predicate <? super T> predicate)
boolean noneMatch(Predicate <? super T> predicate)

var list = List.of("monkey", "2", "chimp");
Stream<String> infinite = Stream.generate(() -> "chimp");
Predicate<String> pred = x -> Character.isLetter(x.charAt(0));

System.out.println(list.stream().anyMatch(pred));  // true
System.out.println(list.stream().allMatch(pred));  // false
System.out.println(list.stream().noneMatch(pred)); // false
System.out.println(infinite.anyMatch(pred));       // true

forEach()

it is common to iterate over the elements of a stream.
on an infinite stream does not terminate.
it is not a reduction.

void forEach(Consumer<? super T> action)

tream<String> s = Stream.of("Monkey", "Gorilla", "Bonobo");
s.forEach(System.out::print); // MonkeyGorillaBonobo

reduce()

The reduce() method combines a stream into a single object.

T reduce(T identity, BinaryOperator<T> accumulator)

Optional<T> reduce(BinaryOperator<T> accumulator)

<U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)

The identity is the initial value of the reduction
The accumulator combines the current result with the current value in the stream.

var array = new String[] { "w", "o", "l", "f" };
var result = "";
for (var s: array) result = result + s;
System.out.println(result); // wolf

Stream<String> stream = Stream.of("w", "o", "l", "f");
String word = stream.reduce("", (s, c) -> s + c);
System.out.println(word); // wolf

Stream<String> stream = Stream.of("w", "o", "l", "f");
String word = stream.reduce("", String::concat);
System.out.println(word); // wolf

Stream<Integer> stream = Stream.of(3, 5, 6);
System.out.println(stream.reduce(1, (a, b) -> a*b));  // 90

There are three choices for what is in the Optional.
- If the stream is empty, an empty Optional is returned.
- If the stream has one element, it is returned.
- If the stream has multiple elements, the accumulator is applied to combine them.

BinaryOperator<Integer> op = (a, b) -> a * b;
Stream<Integer> empty = Stream.empty();
Stream<Integer> oneElement = Stream.of(3);
Stream<Integer> threeElements = Stream.of(3, 5, 6);

empty.reduce(op).ifPresent(System.out::println);         // no output
oneElement.reduce(op).ifPresent(System.out::println);    // 3
threeElements.reduce(op).ifPresent(System.out::println); // 90

The third method signature is used when we are dealing with different types.

Stream<String> stream = Stream.of("w", "o", "l", "f!");
int length = stream.reduce(0, (i, s) -> i+s.length(), (a, b) -> a+b);
System.out.println(length); // 5

i is Integer and s is a String.
combiner used in parallel streams.

collect()

is a special type of reduction called a mutable reduction.

<R> R collect(Supplier<R> supplier, 
   BiConsumer<R, ? super T> accumulator, 
   BiConsumer<R, R> combiner)

<R,A> R collect(Collector<? super T, A,R> collector)

Stream<String> stream = Stream.of("w", "o", "l", "f");

StringBuilder word = stream.collect(
   StringBuilder::new,
   StringBuilder::append, 
   StringBuilder::append)

System.out.println(word); // wolf

Combiner used in parallel streams;

Stream<String> stream = Stream.of("w", "o", "l", "f");

TreeSet<String> set = stream.collect(
   TreeSet::new, 
   TreeSet::add,
   TreeSet::addAll);

System.out.println(set); // [f, l, o, w]

Stream<String> stream = Stream.of("w", "o", "l", "f");
TreeSet<String> set = 
   stream.collect(Collectors.toCollection(TreeSet::new));
System.out.println(set); // [f, l, o, w]

Stream<String> stream = Stream.of("w", "o", "l", "f");
Set<String> set = stream.collect(Collectors.toSet());
System.out.println(set); // [f, w, l, o]

USING COMMON INTERMEDIATE OPERATIONS

an intermediate operation produces a stream as its result.

filter()

The filter() method returns a Stream with elements that match a given expression.

Stream<T> filter(Predicate<? super T> predicate)

Stream<String> s = Stream.of("monkey", "gorilla", "bonobo");
s.filter(x -> x.startsWith("m"))
   .forEach(System.out::print); // monkey

distinct()

The distinct() method returns a stream with duplicate values removed.

Stream<T> distinct()

Stream<String> s = Stream.of("duck", "duck", "duck", "goose");
s.distinct()
   .forEach(System.out::print); // duckgoose

limit() and skip()

The limit() and skip() methods can make a Stream smaller, or they could make a finite stream out of an infinite stream.

Stream<T> limit(long maxSize)
Stream<T> skip(long n)

Stream<Integer> s = Stream.iterate(1, n -> n + 1);
s.skip(5)
   .limit(2)
   .forEach(System.out::print); // 67

map()

The map() method creates a one‐to‐one mapping from the elements in the stream to the elements of the next step in the stream.

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

Stream<String> s = Stream.of("monkey", "gorilla", "bonobo");
s.map(String::length)
   .forEach(System.out::print); // 676

flatMap()

The flatMap() method takes each element in the stream and makes any elements it contains top‐level elements in a single stream.

<R> Stream<R> flatMap(
   Function<? super T, ? extends Stream<? extends R>> mapper)

List<String> zero = List.of();
var one = List.of("Bonobo");
var two = List.of("Mama Gorilla", "Baby Gorilla");
Stream<List<String>> animals = Stream.of(zero, one, two);

animals.flatMap(m -> m.stream())
   .forEach(System.out::println);

Bonobo
Mama Gorilla
Baby Gorilla

sorted()

The sorted() method returns a stream with the elements sorted.

Stream<T> sorted()
Stream<T> sorted(Comparator<? super T> comparator)

Stream<String> s = Stream.of("brown-", "bear-");
s.sorted()
   .forEach(System.out::print); // bear-brown

Stream<String> s = Stream.of("brown bear-", "grizzly-");
s.sorted(Comparator.reverseOrder())
   .forEach(System.out::print); // grizzly-brown bear-

peek()

it allows us to perform a stream operation without actually changing the stream.

Stream<T> peek(Consumer<? super T> action)

var stream = Stream.of("black bear", "brown bear", "grizzly");
long count = stream.filter(s -> s.startsWith("g"))
   .peek(System.out::println).count();              // grizzly
System.out.println(count);                          // 1

PUTTING TOGETHER THE PIPELINE

var list = List.of("Toby", "Anna", "Leroy", "Alex");
list.stream()
   .filter(n -> n.length() == 4)
   .sorted()
   .limit(2)
   .forEach(System.out::println);

Stream.generate(() -> "Elsa")
   .filter(n -> n.length() == 4)
   .limit(2)
   .sorted()
   .forEach(System.out::println);

Working with Primitive Streams

CREATING PRIMITIVE STREAMS

IntStream: Used for the primitive types int, short, byte, and char
LongStream: Used for the primitive type long
DoubleStream: Used for the primitive types double and float

Method	Primitive stream	Description
OptionalDouble average()	IntStream LongStream DoubleStream	The arithmetic mean of the elements
Stream<T> boxed()	IntStream LongStream DoubleStream	A Stream where T is the wrapper class associated with the primitive value
OptionalInt max() OptionalLong max() OptionalDouble max()	IntStream LongStream DoubleStream	The maximum element of the stream
OptionalInt min() OptionalLong min() OptionalDouble min()	IntStream LongStream DoubleStream	The minimum element of the stream
IntStream range(int a, int b) LongStream range(long a, long b)	IntStream LongStream	Returns a primitive stream from a (inclusive) to b (exclusive)
IntStream rangeClosed(int a, int b) LongStream rangeClosed(long a, long b)	IntStream LongStream	Returns a primitive stream from a (inclusive) to b (inclusive)
int sum() long sum() double sum()	IntStream LongStream DoubleStream	Returns the sum of the elements in the stream
IntSummaryStatistics summaryStatistics() LongSummaryStatistics summaryStatistics() DoubleSummaryStatistics summaryStatistics()	IntStream LongStream DoubleStream	Returns an object containing numerous stream statistics such as the average, min, max, etc.

Table - Common primitive stream methods

Examples:
Creating streams

DoubleStream empty = DoubleStream.empty();

DoubleStream oneValue = DoubleStream.of(3.14);
oneValue.forEach(System.out::println);

DoubleStream varargs = DoubleStream.of(1.0, 1.1, 1.2);
varargs.forEach(System.out::println);

3.14
1.0
1.1
1.2

Creating infinite streams

var random = DoubleStream.generate(Math::random);
var fractions = DoubleStream.iterate(.5, d -> d / 2);
random.limit(3).forEach(System.out::println);
fractions.limit(3).forEach(System.out::println);

0.07890654781186413
0.28564363465842346
0.6311403511266134
0.5
0.25
0.125

Using range

IntStream range = IntStream.range(1, 6);
range.forEach(System.out::println);

IntStream rangeClosed = IntStream.rangeClosed(1, 5);
rangeClosed.forEach(System.out::println);

MAPPING STREAMS

Another way to create a primitive stream is by mapping from another stream type.

Source stream class	To create Stream	To create DoubleStream	To create IntStream	To create LongStream
Stream	map()	mapToDouble()	mapToInt()	mapToLong()
DoubleStream	mapToObj()	map()	mapToInt()	mapToLong()
IntStream	mapToObj()	mapToDouble()	map()	mapToLong()
LongStream	mapToObj()	mapToDouble()	mapToInt()	map()

Mapping methods between types of streams

example

Stream<String> objStream = Stream.of("penguin", "fish");
IntStream intStream = objStream.mapToInt(s -> s.length());

Source stream class	To create Stream	To create DoubleStream	To create IntStream	To create LongStream
Stream	Function	ToDoubleFunction	ToIntFunction	ToLongFunction
DoubleStream	Double Function	DoubleUnary Operator	DoubleToInt Function	DoubleToLong Function
IntStream	IntFunction	IntToDouble Function	IntUnary Operator	IntToLong Function
LongStream	Long Function	LongToDouble Function	LongToInt Function	LongUnary Operator

Function parameters when mapping between types of streams

flatmap() on primitive streams has a different method name

var integerList = new ArrayList<Integer>();
IntStream ints = integerList.stream()
.flatMapToInt(x -> IntStream.of(x));
DoubleStream doubles = integerList.stream()
.flatMapToDouble(x -> DoubleStream.of(x));
LongStream longs = integerList.stream()
.flatMapToLong(x -> LongStream.of(x));

USING OPTIONAL WITH PRIMITIVE STREAMS

var stream = IntStream.rangeClosed(1,10);
OptionalDouble optional = stream.average();

optional.ifPresent(System.out::println);                  // 5.5
System.out.println(optional.getAsDouble());               // 5.5
System.out.println(optional.orElseGet(() -> Double.NaN)); // 5.5

OptionalDouble is for a primitive and Optional is for the Double wrapper class.
getAsDouble() rather than get().
orElseGet() takes a DoubleSupplier instead of a Supplier.

	OptionalDouble	OptionalInt	OptionalLong
Getting as a primitive	getAsDouble()	getAsInt()	getAsLong()
orElseGet() parameter type	DoubleSupplier	IntSupplier	LongSupplier
Return type of max() and min()	OptionalDouble	OptionalInt	OptionalLong
Return type of sum()	double	int	long
Return type of average()	OptionalDouble	OptionalDouble	OptionalDouble