Advanced Java course covering Java 8 through Java 13

This programming approach is about how a program should be executed step by step

This approach is about not necessarily how but what should be executed

Lambda expression is an anonymous function without a name that doesn't belong to any class.

Method                  |           Lambda Expression
------------------------------------------------------
Name                    |           No Name
Parameters List         |           Parameters list
Body                    |           Body (main part)
return type             |           No return type(JVM infers the return type by scanning the code)               

General Syntax
()              ->          { }
Lambda         Arrow        Lambda 
Input          denoting     Body
Parameters     Lambda

Any interface with Single Abstract method is a functional interface and implementation may be treated as lambda expression

@FunctionalInterface annotation denotes that method can be treated as lambda expression.
Functional interface have default and static methods which have an implementation
It also means the interface has ONLY one abstract method

It is a part of java.util.function package
It takes one argument and produces the result, it doesn't return any result

It takes two arguments, BiConsumer does not return value.

It's a single argument function that returns true or false

It's a functional interface which accepts two argument and returns Boolean value.
Apply business logic for the values passed as an argument and return the boolean value.

It takes one argument and produces results.

It takes two arguments and produces results.
While declaring BiFunction we need to tell what type of argument will be passed and what will be return type. We can apply our business logic with those two values and return the result.

It's an interface where the operand and result are of same type. It extends from Function interface. There are IntUnaryOperator, LongUnaryOperator and DoubleUnaryOperator types.

It takes two params and return single value
Both params must be of same type so is return type
Generally used for mathematical use cases
IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator are specific interfaces

This is opposite of Consumer Interface
This is a factory interface

Each time if the lambda expression is referring the method then it can be relaced with method reference
For e.g: String -> System.out.print(str) can be replaced like System.out::print
Types:
Class:: staticMethod() // Reference to static method object::instanceMethod // Reference to an instance method Class::new // Reference to constructor

The body of lambda has same scope as nested block
We can't declare param name to lambda function and local var name as same
Effect Final: This means that local var can't be modified in the lambda function even though they are
not declared as final

Stream is a sequence of objects that support various methods and can be pipelined to produce result
Stream supports Map-reduce-filter transformation on collection
** Streams are effective only when terminating operation is executed. For e.g. .collect(...)

Collection                  |           Streams
--------------------------------------------------------------
Used for storing and        | Used for performing operation on 
grouping the data           | input from collection
                            |
Can add/remove elements     | Can't add/remove elements
                            |
Have to be iterated         | Streams are internally iterated
Externally                  |

Can be traversed multiple   | Streams are traversed only once
times                       |

Eagerly constructed         | Lazy construction
E.g. List, map, Set,        | e.g. Filtering, mapping, reduce

Debugging the Stream can be done in two ways:

1. Run the code in debug mode and then open up the "Trace Current Stream Chain" option (Intellij)
2. use peek() to check the state of that stream at that point

1. It converts stream of x to stream of y
2. It's a internmediate operation and return stream as method return

1. It's a combination of MAP and Flat operation,
2. Used for flatten the stream,

Method to filter or collect all distinct elements from the collection

Returns the count of elements in the stream

Sorted order of elements based on natural order

returns whether any element of this stream match the provided predicate

return whether all elements of this stream match the provided predicate

returns whether no elements of this stream match the provided predicate

Stream filter with Predicate argument returns the stream of elements matching the given predicate
** This filter is lazy operation meaning, filter doesn't actually perform any filtering but instead creates a new stream that when traversed contains the elements of the initial stream that matches the predicate

Reduce the repeated process of combining all elements
It takes an input of elements and combines them into single result by combining operations
like sum, multiplication, division etc.
T reduce(identity, BinaryOperator)
Optional reduce(BinaryOperator)

Optional is a container object which may or may not contain a non-value

It takes one (long) argument and returns the stream of size number more than n

It takes one long (n) as argument and returns a stream after removing first n elements

It returns an Optional Object containing first element of the stream OR an empty Optional
Object

It returns an Optional Object containing any one element of the stream OR an empty Optional Object

Factory Methods

Used for creating stream from similar type of data

Used to generate an infinite sequential ordered stream produced by
iterative application of the provided UnaryOperator. The seed is initial element of iteration.

Used to generate an infinite sequential unordered stream where each element is
generated by the provided Supplier.

These streams are for primitive streams respectively for integer, long and double

sum(), max(), min(), average()

Converting a primitive to a wrapper class object type is boxing

Converting a wrapper object type to a primitive type is unboxing

For further reference, please consider the following sections:

It returns an object valued Stream

It returns LongStream consisting of the results of the given function

It returns DoubleStream consisting of the results of the given function

It concatenates the input elements into string in encounter order

It concatenates the input elements into String separated by the specified delimiter

It concatenates the input elements separated by the specified delimiter with specified prefix and suffix in the encounter order

Count the no of elements in a stream

Collectors class mapping() method takes a function and collector and creates a new collector which apply
the function and then collects the mapped elements using the given collectors

minBy returns the collector that produces the minimal elements according to a given comparator
maxBy returns the collector that produces the maximum elements according to a given comparator

summingInt() returns a collector that constructs sum of the integer valued function applied to input elements
averagingInt() returns a collector that constructs average of the integer valued function applied to input elements

This method provides functionality similar to groupBy in SQL. Output is Map(K,V) There are 3 factory methods
groupingBy(classifier)
groupingBy(classifier, downstream)
groupingBy(classifier, mapFactory, downstream)

This method is used to partition a stream of objects based on a given predicate
Factory methods()
partitioningBY(predicate) returns the Map<Boolean, List>
partitioningBY(predicate, downstream) returns the Map<Boolean, List>

Parallel stream leverages multicore processors resulting in a substantial increase in performance
This uses fork/join framework
There are 2 ways to achieve parallel streams

1. calling parallelStream() on collection
2. Calling parallel() on stream

This class is in util package and help to avoid null checks
Factory methods are

OrElse - get the value if present or returns the alternative value
OrElseGet - get the value or gets the supplier value
OrElseThrow - throw the exception produced by supplier function or else return the value

overloaded/overridden methods are always executed in following order
First from the class implementing then from the sub interfaces(child interfaces) and then from parent interfaces

An instant is defined as an instant in teh datetime continuum specified as a number of milliseconds from
1970-01-00.00.00.000000000
This represents the start of the nanosecond on teh timeline.

JShell was introduced in Java 9. It's a interactive tool for learning and prototyping Java code.
REPL: Read-Evaluate-Print-Loop can help flatten out the learning curve of Java
It shows the results as we code. The evaluation of code happens as we type. REPL is used for writing and testing small code snippets
Intellij gives JShell console built under tools menu.

Java 9 introduced an abstraction layer on top of packages which is called Java Platform Module System
java --list-modules to list the modules in JDK

it is a try statement that declares one or more resource(s)
Resource is an object that must be closed after the program is finished with
try-with-resource makes sure that the resource is closed
Resource should implement AutoClosable OR java.io.Closeable

Starting Java 10 we can drop explicitly referring the variable type depending upon whether compiler can infer the type
Remember class level var(s) is not allowed, only local var as in method

G1 Garbage first collection algorithm is improved with it's worst case latency (Parallel full GC)

These are different from switch statements. No boiler plate code, no break statements.

Denoted by """ (3 quotes)