Returns a {@link LongBinaryOperator} sum operation. @return binary sum operation

Receives int parameter n, and returns a {@link Supplier} that supplies {@link IntUnaryOperator} that is a function f(x) = n x @param n a multiplier @

Returns a {@link Consumer} that accepts {@link Runnable} as a parameter and runs in a new thread. @return a runnable consumer

Creates and returns an instance of {@link ArrayList} with provided elements @param elements to add @return new instance

Creates two new {@link Node} objects using provided firstElement and secondElement, and create a connection between those two elements so the first no

Returns a map that separates all accounts into two lists - male and female. Map has two keys {@code true} indicates male list, and {@code false} indic

An if statement is a classic example of imperative check

StreamMapping elements, method map() receives a @{@link java.util.function.Function}. This function transforms(maps) each element of the stream into a

or add a default value. Now you're safely trying to get an account instance, because in case it's null you'll get a default value

The version with {@link Supplier} should be used in case getting default value requires additional resources. In this case default instance will be on

The right way is to pass a consumer that will be used in case {@link Optional} value is not empty

It is not correct to process to process {@link Optional} values in the old imperative way, as it is shown below

To filter accounts we use an instance of @{@link Predicate} that checks if an email is gmail based @param accounts

An example, when you process a stream and find an optional element, with an relation that can be null

Hierarchical relation with potential null value, like an account that can be null, has a balance field that also can be null

When you want to access a nullable value of account, you can use method map(), that receives a mapper which transform your nullable value into an opti

Please always use joining() method to avoid performance issues when concatenating {@link String}

When you use map() it wraps a value within Optional container, and if that field is already an {@link Optional}, you get Optional<Optional<T>>. To avo

Since forEach() is a terminal operation, you can not continue working with stream when it's performed. That's why Stream API provides another method,

{@link LongStream} is a stream of primitive long values. It can also be boxed into a {@link Stream} of {@link Long} values. PLEASE NOTE, that you shou

Please note that reduce() was use just an example. The better way to find max balance is to use accounts.stream().max(comparing(Account::getBalance))

This method creates a {@link Stream} of {@link Account} and then maps it to stream of doubles. To transform stream of objects like an {@link Account}

Use streams carefully. Always keep the logic simple and clear. In case it becomes too complex, think how to simplify it use imperative style

This is an example of declarative check. You don't write an if statement yourself, it is performed inside the method ifPresentOrElse()

Instead of using imperative if-else statement, use ifPresentOrElse() method

Stream API allow you to skip some elements, and limit the number of elements in the stream

This is the unbound method reference example. Since we used unbound method reference, the {@link Function} can receive a string as an input parameter.

This is the bound method reference example. We actually reference a method that is bound to concrete string instance. Since we reference a concrete st

This is the unbound method reference example. Since toUpperCase() receives and returns the same type {@link String}, we can easily replace {@link Func

Finds an {@link Account} with max balance and processes it using {@link AccountService#processAccount(Account)} @param accounts @param accountService

Find a prime number by index and then applies a provided consumer passing found prime number @param idx the position of a prime number (index),

Returns a {@link Supplier} of random integers @return int supplier

Returns a {@link Function} that accepts an instance of {@link Runnable} and returns a {@link Supplier} of a started {@link Thread} that is created fro

Receives a {@link Runnable} parameter, and returns a {@link Supplier<Thread>}. The thread will be started only when you call supplier method {@link Su

Returns the number of entries (key-value mappings). @return the number of entries

Return a {@link Function} that accepts {@link String} and returns that string repeated n time, where n is passed as function argument @return functio

Returns a {@link ToIntFunction<String>} that converts string to integer. @return string to int converter

Returns a comparator of type T that uses a provided comparator to compare objects, and only if they are equal it's comparing values extracted using th

Returns a {@link Function} that converts a {@link BigDecimal} number into a {@link String} that start with a dollar sign and then gets a value @retur

Returns {@link Supplier} of {@link Supplier} of {@link Supplier} of {@link String} "WELL DONE!". @return a supplier instance

This constructor creates an instance of {@link ArrayList} with a specific capacity of an array inside. @param initCapacity - the initial capacity of