Major Sources of JAVA SE 8: java.util & java.lang etc.

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/util/function

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/util/

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/lang

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/time

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/text

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/sql

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/security

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/io

  http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/nio  

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/math

In general:

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/

Guide to Stream.reduce()

https://www.baeldung.com/java-stream-reduce 

Reduction (The Java Tutorials > Collections > Aggregate Operations)

https://docs.oracle.com/javase/tutorial/collections/streams/reduction.html 

REMINDER: substring - ending index is exclusive! => "S".equals("String".substring(0,1))

REMINDER: substring - ending index is exclusive! => "S".equals("String".substring(0,1))

Parameters
startIndex : starting index is inclusive, and starts at 0
endIndex : ending index is exclusive

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#substring(int,int)
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html
https://www.javatpoint.com/java-string-substring

"north".substring(0,1) => "n"
"north".substring(1,2) => "o"
"north".substring(1,3) => "or"
 "hamburger".substring(4, 8) returns "urge"
 "smiles".substring(1, 5) returns "mile"

Signature:
public String substring(int startIndex)  
and  
public String substring(int startIndex, int endIndex)  
If you don't specify endIndex, java substring() method will return all the characters from startIndex.

BiFunction (Java Platform SE 8 )

Sources:

https://docs.oracle.com/javase/8/docs/api/java/util/function/BiFunction.html

https://mkyong.com/java8/java-8-bifunction-examples/

T1, T2 - - - - > R

compose() and andThen() methods in java.util.function.Function (Java Platform SE 8 )

Source:

https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html#compose-java.util.function.Function-

• apply

  R apply(T t)

  Applies this function to the given argument.

  Parameters:

  t - the function argument

  Returns:

  the function result

• compose

  default <V> Function<V,R> compose(Function<? super V,? extends T> before)

  Returns a composed function that first applies the before function to its input, and then applies this function to the result. If evaluation of either function throws an exception, it is relayed to the caller of the composed function.

  Type Parameters:

  V - the type of input to the before function, and to the composed function

  Parameters:

  before - the function to apply before this function is applied

  Returns:

  a composed function that first applies the before function and then applies this function

  Throws:

  NullPointerException - if before is null

  See Also:

  andThen(Function)

• andThen

  default <V> Function<T,V> andThen(Function<? super R,? extends V> after)

  Returns a composed function that first applies this function to its input, and then applies the after function to the result. If evaluation of either function throws an exception, it is relayed to the caller of the composed function.

  Type Parameters:

  V - the type of output of the after function, and of the composed function

  Parameters:

  after - the function to apply after this function is applied

  Returns:

  a composed function that first applies this function and then applies the after function

  Throws:

  NullPointerException - if after is null

  See Also:

  compose(Function)

Modern JAVA: What is the difference between intermediate and terminal operations?

Source:

https://stackoverflow.com/questions/47688418/what-is-the-difference-between-intermediate-and-terminal-operations/47693257

"A Stream supports several operations and these operations are divided into intermediate and terminal operations.

The distinction between this operations is that an intermediate operation is lazy while a terminal operation is not. When you invoke an intermediate operation on a stream, the operation is not executed immediately. It is executed only when a terminal operation is invoked on that stream. In a way, an intermediate operation is memorized and is recalled as soon as a terminal operation is invoked. You can chain multiple intermediate operations and none of them will do anything until you invoke a terminal operation. At that time, all of the intermediate operations that you invoked earlier will be invoked along with the terminal operation.

All intermediate operations return Stream (can be chained), while terminal operations don't. 

Intermediate Operations are:

filter(Predicate<T>)  map(Function<T>)  flatMap(Function<T>)  sorted(Comparator<T>)  peek(Consumer<T>)  distinct()  limit(long n)  skip(long n)  

Terminal operations produces a non-stream (cannot be chained) result such as primitive value, a collection or no value at all.

Terminal Operations are:

forEach  forEachOrdered  toArray  reduce  collect  min  max  count  anyMatch  allMatch  noneMatch  findFirst      findAny  

Last 5 are short-circuiting terminal operations"

Java: static final methods and their usage

Source:

https://geekster.pl/java/metody-i-skladowe-statyczne-oraz-finalne/

Java: static final methods and their usage

LAMBA and Interfaces in modern Java - References to different methods...

Source:

https://bulldogjob.pl/news/1361-interfejsy-w-javie-referencje-metod

"referencje do metod pozwalają odwoływać się do metod bez ich wykonywania. Możliwość ta jest związana z wyrażeniami lambda, gdyż także wymaga kontekstu typu docelowego będącego interfejsem funkcyjnym. W momencie przetwarzania także referencja do metody tworzy instancję interfejsu funkcyjnego. 

Dostępnych jest kilka różnych rodzajów referencji do metod"

"* referencje do metod statycznych, 

* referencje do metod instancyjnych, 

* referencje do metod a typy sparametryzowane, 

* a także referencje do konstruktorów."

"Składnia używana do do tworzenia referencji do metod statycznych wygląda tak:" 

NazwaKlasy::nazwaMetody

Functional interface in Java SE 8+ = an interface with 1 abstract method (not derived from Object class)

Sources:

https://www.javappa.com/kurs-java/java8/interfejs-funkcyjny-co-to-jest

https://www.javappa.com/kurs-angularjs

https://www.javappa.com/kurs-spring/projekt-startowy-spring-boot

Functional interface in Java SE 8+ = an interface with 1 abstract method (not derived from Object class). 

Abstract method means with no body and not implemented.

We can also tell the compiler to treat it as a @FunctionalInterface with this annotation.

Default methods of such interfaces (with "default" keyword) are implemented with body here, and are not abstract since Java SE 8.

Java SE 8+ STREAM: peek() vs. forEach() etc.

Sources:

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html

https://www.baeldung.com/java-streams-peek-api

https://programuj.pl/blog/java8-strumienie-cz3-peek-map-collect

<R,A> R	collect(Collector<? super T,A,R> collector) Performs a mutable reduction operation on the elements of this stream using a Collector.
<R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) Performs a mutable reduction operation on the elements of this stream.

Stream<T>

filter(Predicate<? super T> predicate) Returns a stream consisting of the elements of this stream that match the given predicate.

static <T> Stream<T>	generate(Supplier<T> s) Returns an infinite sequential unordered stream where each element is generated by the provided Supplier.
static <T> Stream<T>	iterate(T seed, UnaryOperator<T> f) Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
Stream<T>	limit(long maxSize) Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
<R> Stream<R>	map(Function<? super T,? extends R> mapper) Returns a stream consisting of the results of applying the given function to the elements of this stream.

static <T> Stream<T>	of(T... values) Returns a sequential ordered stream whose elements are the specified values.
static <T> Stream<T>	of(T t) Returns a sequential Stream containing a single element.

Optional<T>	reduce(BinaryOperator<T> accumulator) Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.
T	reduce(T identity, BinaryOperator<T> accumulator) Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
<U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner) Performs a reduction on the elements of this stream, using the provided identity, accumulation and combining functions.

<R> Stream<R>

flatMap(Function<? super T,? extends Stream<? extends R>> mapper) Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.

void	forEach(Consumer<? super T> action) Performs an action for each element of this stream.

Stream<T>

peek(Consumer<? super T> action) Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.

ThreadLocal (Java Platform SE 7 ) and AtomicInteger...

Source:

https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html

import java.util.concurrent.atomic.AtomicInteger;  
import java.lang.ThreadLocal<T>;

   public class ThreadId {       // Atomic integer containing the next thread ID to be assigned       private static final AtomicInteger nextId = new AtomicInteger(0);         // Thread local variable containing each thread's ID       private static final ThreadLocal<Integer> threadId =           new ThreadLocal<Integer>() {               @Override protected Integer initialValue() {                   return nextId.getAndIncrement();           }       };         // Returns the current thread's unique ID, assigning it if necessary       public static int get() {           return threadId.get();       }   }

StringUtils (Apache Commons Lang 3.12.0 API)

http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringUtils.html 

Java Stream flatMap(). HOW-TO

Source:

https://howtodoinjava.com/java8/stream-flatmap-example/#:~:text=flatMap()%20is%20an%20intermediate,mapping%20function%20to%20each%20element

flatMap() - sample of flattening:

Flattening example 1

Before flattening   : [[1, 2, 3], [4, 5], [6, 7, 8]] After flattening    : [1, 2, 3, 4, 5, 6, 7, 8]

Flattening example 2

Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8); Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +")));

Similar flatMap() Methods

IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper) LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper) DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)