Java Concurrency : Statistics Project

GitLab : https://github.com/zaheerahmed8845/concurrency.git

Assumptions

1. We are not using benchmarking tool(JMH), thus the test will not include.
   1. WarmUp
   2. Multi Instance JVM runs
2. The Throughput(Write/Read) is calculated within the RunController.java in code. Below read to write ratios
   are calculated.
         R : W = 1 : 1
         R : W = 5 : 1
         R : W = 1 : 5

Components
1. Controller: This starts the Write and Read Processors and calculates the throughput of the application.
   1. runs : Number of times the processes runs. At the end of the run it captures the throughput for each individual run and calculates the average.

   2. algo : This accepts a numerical value and which algo to run, below is the mapping.
      1 -> StatisticsWithoutStorageImpl.java
      2 -> StatisticsWithStorageCOWAImpl.java
      3 -> StatisticsWithStorageCLQImpl.java
      4 -> StatisticsWithALLockImpl.java
2. Write Processor: It calls the Statistics.event() method.
   1. NoOfThreads=The number of write processor threads that are started.
   2. Count=The counts each threads call the Statistics.event() method by a single thread. It uses a random generator to generate the value.
   3. Interval=The delay between calling the Statistics.event() method by a single thread.
3. Read Processor: It calls the statistics read methods - min(), max(), mean(), variance().
    1. NoOfThreads=The number of read processor threads that are started.
    2. Count=The counts each threads call the statistics read methods by a single thread. For each call, it will call a single read method randomly.
    3. Interval=The delay between calling the statistics read methods by a single thread.

Run Types
1. No Storage/Historical Events : 
   1. Refer the class : StatisticsWithoutStorageImpl.java
   2. This is a blocking(not lock free) - the write method and read(variance) method are implemented by a lock.
   3. In this we do not persist any data.
   4. All the read values are computed at the time of addition.
   5. The read values are consistent.
2. Storage/Historical Events : 
   1. ConcurrentLinkedQueue :
      1. Refer the class: StatisticsWithStorageCLQImpl.java
      2. This is a lock free and non-blocking for all the read and write operations.
      3. In this we persist all the data.
      4. The read values are computed for each call.
      5. High compute read operations(variance) is calculated using Completable Future.
      6. The read values are not consistent.
   2. CopyOnWriteArrayList
      1. Refer the class: StatisticsWithStorageCOWAImpl.java
      2. This is a lock free and non-blocking for all the read and write operations.
      3. In this we persist all the data.
      4. The read values are computed for each call.
      5. High compute read operations(variance) is calculated using Parallel Stream.
      6. The read values are not consistent.
   3. Lock and Array List
      1. Refer the class : StatisticsWithALLockImpl.java
      2. This is a blocking(not lock free) - the write method and all read methods are implemented by a lock.
      3. In this we persist all the data.
      4. The read values are computed for each call.
      5. High compute read operations(variance) is calculated using Parallel Stream.
      6. The read values are consistent.

Throughput Performance

1. Read : Write = 1 : 1
    
    | RunType                             | Operation Type  | No of Threads  | Count   | Throughput(requests/sec) |
    |-------------------------------------|-----------------|----------------|---------|--------------------------|
    | No Storage                          | Write           | 10             | 5000    | 50k                      |
    |                                     | Read            | 10             | 5000    | 50k                      |
    | Storage - ConcurrentLinkedQueue     | Write           | 10             | 5000    | 50k                      |
    |                                     | Read            | 10             | 5000    | 22k                      |
    | Storage - CopyOnWriteArrayList      | Write           | 10             | 5000    | 50k                      |
    |                                     | Read            | 10             | 5000    | 25k                      |
    | Storage - Lock and Array List       | Write           | 10             | 5000    | 50k                      |
    |                                     | Read            | 10             | 5000    | 50k                      |

2. Read : Write = 1 : 5

   | RunType                             | Operation Type  | No of Threads | Count   | Throughput(requests/sec) |
   |-------------------------------------|-----------------|---------------|---------|--------------------------|
   | No Storage                          | Write           | 50            | 5000    | 250k                     |
   |                                     | Read            | 10            | 5000    | 50k                      |
   | Storage - ConcurrentLinkedQueue     | Write           | 50            | 5000    | 250k                     |
   |                                     | Read            | 10            | 5000    | 3.5k                     |
   | Storage - CopyOnWriteArrayList      | Write           | 50            | 5000    | 16k                      |
   |                                     | Read            | 10            | 5000    | 16k                      |
   | Storage - Lock and Array List       | Write           | 50            | 5000    | 208k                     |
   |                                     | Read            | 10            | 5000    | 41k                      |

3. Read : Write = 5 : 1

   | RunType                             | Operation Type  | No of Threads | Count    | Throughput(requests/sec) |
   |-------------------------------------|-----------------|---------------|----------|--------------------------|
   | No Storage                          | Write           | 10            | 5000     | 50k                      |
   |                                     | Read            | 50            | 5000     | 250k                     |
   | Storage - ConcurrentLinkedQueue     | Write           | 10            | 5000     | 6k                       |
   |                                     | Read            | 50            | 5000     | 26k                      | 
   | Storage - CopyOnWriteArrayList      | Write           | 10            | 5000     | 9k                       |
   |                                     | Read            | 50            | 5000     | 3.7k                     |
   | Storage - Lock and Array List       | Write           | 10            | 5000     | 30k                      |
   |                                     | Read            | 50            | 5000     | 152k                     |


Trade-off

   | RunType                               | Write Consistency | Read Consistency |
   |---------------------------------------|-------------------|------------------|
   | No Storage                            | Yes               | Yes              |
   | Storage - ConcurrentLinkedQueue       | Yes               | No               |
   | Storage - CopyOnWriteArrayList        | Yes               | No               |
   | Storage - Lock and Array List         | Yes               | Yes              |

FAQ

1: When using ConcurrentLinkedQueue for high compute read task like variance why was 
CompletableFuture used instead of Parallel Stream?
A: The performance of parallelstream is good with arraylist but poor with LinkedList, 
Since ConcurrentLinkedQueue uses the underlying datastructure as LinkedList, hence the queue partition 
and parallel execution needed to be written explicitly. 

2: Why was only the variance() method had parallelism enabled and not the other read methods?
A: I have tested with inserting 500M writes and then performing the read computations, the other read
operations where performing better sequentially compared to parallel tasks. Since variance was performing bad
hence it had computation paralley enabled.

3: The executor used in CompletableFuture uses "Runtime.getRuntime().availableProcessors()" threads, 
why have you not provided fixed no of threads?
A: Since we do not have IO operation and only compute, hence providing a number of threads greater or lesser
than the core available will not make it efficient.

4: Why you could not test with inserts more than 500M?
A: My machines resources max could stretch till. For going beyond this my RAM would not suffice and would
require an external resource or file system for storage which would require additional effort and beyond the scope
of this problem statement.

5: In the class StatisticsWithStorageCLQImpl, the size and add to the queue can have a race condition?
A: Yes, this can happen the size is used to decide if it is parallel or sequential processing and does 
not impact any of the read computations. 

6: Why is the Single Writer Principle not used in the above algorithms?
A: It could not make the throughput performance any better. For the above tests, but we could use it where the 
writes are less and reads are more(read-heavy application). All the min(), max(), mean() and variance() will be calculated
as part of write method. 

Improvements in the Statstistics Interface
1. The current methods do not have a limit on which the min(), max(), mean() and variance() are calculated.
This could be improved by having a limit. For example: Find the min() value for the last 1000 elements.

Design Patterns : Tutorial 2

Visitor Design Pattern

public interface ItemElement {

       public int accept(ShoppingCartVisitor visitor);

}

public class Book implements ItemElement {

       private int price;

       private String isbnNumber;

       public Book(int cost, String isbn){

              this.price=cost;

              this.isbnNumber=isbn;

       }

       public int getPrice() {

              return price;

       }

       public String getIsbnNumber() {

              return isbnNumber;

       }

       @Override

       public int accept(ShoppingCartVisitor visitor) {

              return visitor.visit(this);

       }

}

public class Fruit implements ItemElement {

       private int pricePerKg;

       private int weight;

       private String name;

       public Fruit(int priceKg, int wt, String nm){

              this.pricePerKg=priceKg;

              this.weight=wt;

              this.name = nm;

       }

       public int getPricePerKg() {

              return pricePerKg;

       }

       public int getWeight() {

              return weight;

       }

       public String getName(){

              return this.name;

       }

       @Override

       public int accept(ShoppingCartVisitor visitor) {

              return visitor.visit(this);

       }

}

public interface ShoppingCartVisitor {

       int visit(Book book);

       int visit(Fruit fruit);

}

public class ShoppingCartVisitorImpl implements ShoppingCartVisitor {

       @Override

       public int visit(Book book) {

              int cost=0;

              //apply 5$ discount if book price is greater than 50

              if(book.getPrice() > 50){

                     cost = book.getPrice()-5;

              }else cost = book.getPrice();

              System.out.println("Book ISBN::"+book.getIsbnNumber() + " cost ="+cost);

              return cost;

       }

       @Override

       public int visit(Fruit fruit) {

              int cost = fruit.getPricePerKg()*fruit.getWeight();

              System.out.println(fruit.getName() + " cost = "+cost);

              return cost;

       }

}

public class ShoppingCartClient {

       public static void main(String[] args) {

              ItemElement[] items = new ItemElement[]{new Book(20, "1234"),new Book(100, "5678"),

                           new Fruit(10, 2, "Banana"), new Fruit(5, 5, "Apple")};

              int total = calculatePrice(items);

              System.out.println("Total Cost = "+total);

       }

       private static int calculatePrice(ItemElement[] items) {

              ShoppingCartVisitor visitor = new ShoppingCartVisitorImpl();

              int sum=0;

              for(ItemElement item : items){

                     sum = sum + item.accept(visitor);

              }

              return sum;

       }

}

Output:

Book ISBN::1234 cost =20

Book ISBN::5678 cost =95

Banana cost = 20

Apple cost = 25

Total Cost = 160

Benefits of Visitor pattern:

The benefit of this pattern is that if the logic of operation changes, then we need to make change only in the visitor implementation rather than doing it in all the item classes.

Another benefit is that adding a new item to the system is easy, it will require change only in visitor interface and implementation and existing item classes will not be affected.

Composite Design Pattern

This pattern is used to populate a tree like structure. The real example for this can be shown as an hierarchy in company where there is CEO under him the GM then the Manager and finally the Employee. This consists of three parts.

• Component
• • declares interface for objects in composition.
  • implements deafault behaviour for the interface common to all classes as appropriate.
  • declares an interface for accessing and managing its child components.
• Leaf
• • represents leaf objects in the composition.A leaf has no children.
  • defines behaviour for primitive objects in the composition.
• Composite
• • defines behaviour for components having children.
  • stores child components.
  • implements child related operations in the component interface.
• Client
• • manipulates objects in the composition through the component interface.

public interface Employee {

     public void add(Employee employee);

     public void remove(Employee employee);

     public Employee getChild(int i);

     public String getName();

     public double getSalary();

     public void print();

}

public class Manager implements Employee{

 private String name;

 private double salary;

 public Manager(String name,double salary){

  this.name = name;

  this.salary = salary;

 }

 List<Employee> employees = new ArrayList<Employee>();

 public void add(Employee employee) {

    employees.add(employee);

 }

 public Employee getChild(int i) {

  return employees.get(i);

 }

 public String getName() {

  return name;

 }

 public double getSalary() {

  return salary;

 }

 public void print() {

  System.out.println("-------------");

  System.out.println("Name ="+getName());

  System.out.println("Salary ="+getSalary());

  System.out.println("-------------");

  Iterator<Employee> employeeIterator = employees.iterator();

    while(employeeIterator.hasNext()){

     Employee employee = employeeIterator.next();

     employee.print();

    }

 }

 public void remove(Employee employee) {

  employees.remove(employee);

 }

}

public class Developer implements Employee{

    private String name;

    private double salary;

    public Developer(String name,double salary){

        this.name = name;

        this.salary = salary;

    }

    public void add(Employee employee) {

        //this is leaf node so this method is not applicable to this class.

    }

    public Employee getChild(int i) {

        //this is leaf node so this method is not applicable to this class.

        return null;

    }

    public String getName() {

        return name;

    }

    public double getSalary() {

        return salary;

    }

    public void print() {

        System.out.println("-------------");

        System.out.println("Name ="+getName());

        System.out.println("Salary ="+getSalary());

        System.out.println("-------------");

    }

    public void remove(Employee employee) {

        //this is leaf node so this method is not applicable to this class.

    }

}

public class CompositeDesignPatternMain {

 public static void main(String[] args) {

  Employee emp1=new Developer("John", 10000);

  Employee emp2=new Developer("David", 15000);

  Employee manager1=new Manager("Daniel",25000);

  manager1.add(emp1);

  manager1.add(emp2);

  Employee emp3=new Developer("Michael", 20000);

  Manager generalManager=new Manager("Mark", 50000);

  generalManager.add(emp3);

  generalManager.add(manager1);

  generalManager.print();

 }

}

Observer Design Pattern

This updates the Observers which are registered on the changes of the values. The best example of this can be the waiting and notifying of threads.

PFB the example.

public interface Observer {

       public void update(float temp,float humidity,float pressure);

}

public interface Subject {

       public void registerObservers(Observer o);

       public void removeObservers(Observer o);

       public void notifyObservers();

}

public interface DisplayElement {

       public void display();

}

public class WeatherData implements Subject {

       private ArrayList<Observer> observers;

       private float temperature;

       private float humidity;

       private float pressure;

       public WeatherData(){

              observers = new ArrayList<Observer>();

       }

       public void notifyObservers(){

              for(Observer observer:observers){

                     observer.update(temperature, humidity, pressure);

              }

       }

       public void measurementsChanged(){

              notifyObservers();

       }

       public void setMeasurements(float temperature,float humidity,float pressure){

              this.temperature = temperature;

              this.humidity = humidity;

              this.pressure = pressure;

              measurementsChanged();

       }

       @Override

       public void registerObservers(Observer o) {

              observers.add(o);

       }

       @Override

       public void removeObservers(Observer o) {

              int i = observers.indexOf(o);

              if(i >= 0){

                     observers.remove(i);

              }

       }

}

public class CurrentConditionsDisplay implements Observer,DisplayElement {

       private float temperature;

       private float humidity;

       private Subject weatherData;

       public CurrentConditionsDisplay(Subject weatherData){

              this.weatherData = weatherData;

              weatherData.registerObservers(this);

       }

       @Override

       public void display() {

              System.out.println("Current Conditions: "+temperature + "F degrees and "

                           + humidity + "% humidity");

       }

       @Override

       public void update(float temp, float humidity, float pressure) {

              this.temperature = temperature;

              this.humidity = humidity;

              display();

       }

}

public class WeatherStation {

       public static void main(String[] args) {

              WeatherData weatherData = new WeatherData();

              CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);

              weatherData.setMeasurements(80, 65, 30.4f);

              weatherData.setMeasurements(82, 70, 29.2f);

              weatherData.setMeasurements(78, 90, 29.2f);

       }

}

The Output of this is:

Current Conditions: 0.0F degrees and 65.0% humidity

Current Conditions: 0.0F degrees and 70.0% humidity

Current Conditions: 0.0F degrees and 90.0% humidity

Design Patters : Tutorial 1

These can be majorly divided into three types:

1. Creational Pattern : These patten create a way hiding the creation logic.

               1. Singleton

               2. FactoryPattern

2. Structural Pattern : These patterns are concerned with class and object composition. The Composition of these gives an added functionality.
   1. Decorator                                                     
   2. Adapter
   3. Facade
   4. Composite 
3. Behavioural Pattern : These patterns are concerned with communication between objects.
1. Template
2. Visitor
3. Observer 

Decorator Design Pattern

Usecase : Suppose Star Bucks has various Beverages and it want to charge various customers with different toppings and for this we can use the decorator pattern.

public  abstract class Beverage {

       String description = "Unknown Beverage";

       public String getDescription() {

              return description;

       }

       public abstract double cost();

}

public class Expresso extends Beverage{

       public Expresso(){

              description = "Expresso";

       }

       @Override

       public double cost() {

              System.out.println("Inside Expresso Cost");

              return 1.99;

       }

}

public abstract class CondimentDecorator extends Beverage{

       public abstract String getDescription();

}

public class Mocha extends CondimentDecorator{

       Beverage beverage;

       public Mocha(Beverage beverage){

              this.beverage = beverage;

       }

       public String getDescription(){

              System.out.println("Inside Mocha Description");

              return beverage.getDescription() + " , Mocha ";

       }

       public double cost() {

              System.out.println("Inside Mocha Cost");

              return beverage.cost() + .20;

       }

}

public class Soy extends CondimentDecorator{

       Beverage beverage;

       public Soy(Beverage beverage){

              this.beverage = beverage;

       }

       public String getDescription(){

              System.out.println("Inside Soy Description");

              return beverage.getDescription() + " , Soy ";

       }

       public double cost() {

              System.out.println("Inside Soy Cost");

              return beverage.cost() + .40;

       }

}

public class StarbuzzCoffee {

       public static void main(String[] args) {

              Beverage beverage = new Expresso();

              beverage =  new Mocha(beverage);

              beverage =  new Soy(beverage);

              System.out.println("Description : "+beverage.getDescription()

              +" Cost : "+ beverage.cost());

       }

}

Output of this is:

Inside Soy Description

Inside Mocha Description

Inside Soy Cost

Inside Mocha Cost

Inside Expresso Cost

Description : Expresso , Mocha  , Soy  Cost : 2.59

In this we are adding Mocha and Soy to the Expresso Beverage and hence we override these methods and in the main we call the objects as shown.

RealWorldExample: Java IO Classes.

Facade Design Pattern

The Facade design pattern hides the internal implementation and provides an interface to the user to execute the commands. The example to link to a real world is suppose you want to Watch a movie in your home theatre. Before doing that you need to turn on the popcorn popper,dim the lights, put the screen down etc. For you to remember all these tasks is a challenge and in order to solve this, the Facade design pattern gives the interface which internally handles all these tasks. So lets take an code example of this.

public interface Shape {

       void draw();

}

public class Circle implements Shape {

       public void draw(){

              System.out.println("Rectangle : draw");

       }

}

public class Rectangle implements Shape {

       public void draw(){

              System.out.println("Rectangle : draw");

       }

}

public class Square implements Shape {

       public void draw(){

              System.out.println("Square : draw");

       }

}

public class ShapeMaker {

       private Shape circle;

       private Shape rectangle;

       private Shape square;

       public ShapeMaker(){

              this.circle = new Circle();

              this.rectangle = new Rectangle();

              this.square = new Square();

       }

       public void drawCircle(){

              circle.draw();

       }

       public void drawRectangle(){

              rectangle.draw();

       }

       public void drawSquare(){

              square.draw();

       }

}

public class FacadePatternDemo {

       public static void main(String[] args) {

              ShapeMaker shapeMaker = new ShapeMaker();

              shapeMaker.drawCircle();

              shapeMaker.drawRectangle();

              shapeMaker.drawSquare();

       }

}

Adapter Design Pattern

The best example of a adapter design pattern is that an adapter which is used between the port and the plug.

public interface Duck {

       void quack();

       void fly();

}

public class MallardDuck implements Duck {

       @Override

       public void quack() {

              System.out.println("Quack");

       }

       @Override

       public void fly() {

              System.out.println("I'm flying");

       }

}

public interface Turkey {

       public void gobble();

       public void fly();

}

public class WildTurkey implements Turkey {

       @Override

       public void gobble() {

              System.out.println("Gobble Gobble");

       }

       @Override

       public void fly() {

              System.out.println("I'm flying a short distance");

       }

}

public class TurkeyAdapter implements Duck {

       Turkey turkey;

       public TurkeyAdapter(Turkey turkey){

              this.turkey = turkey;

       }

       @Override

       public void quack() {

              turkey.gobble();

       }

       @Override

       public void fly() {

              for(int i = 0 ; i < 5;i++){

                     turkey.fly();

              }

       }

}

public class DuckTestDrive {

       public static void main(String[] args) {

              MallardDuck duck = new MallardDuck();

              WildTurkey turkey = new WildTurkey();

              Duck turkeyAdapter = new TurkeyAdapter(turkey);

              System.out.println("The Turkey says...");

              turkey.gobble();

              turkey.fly();

              System.out.println("The Duck Says");

              duck.quack();

              duck.fly();

              System.out.println("The TurkeyAdapter says");

              turkeyAdapter.quack();

              turkeyAdapter.fly();

       }

}

Output is:

The Turkey says...

Gobble Gobble

I'm flying a short distance

The Duck Says

Quack

I'm flying

The TurkeyAdapter says

Gobble Gobble

I'm flying a short distance

I'm flying a short distance

I'm flying a short distance

I'm flying a short distance

I'm flying a short distance

Template Design Pattern

This designs the skeleton of the algorithms.Some of the methods are implemented by the class and the rest are overridden by the subclass.

public abstract class CaffeineBeverage {

       final void prepareReceipe() {

              boilWater();

              brew();

              pourInCup();

              addCondiments();

       }

       abstract void brew();

       abstract void addCondiments();

       void boilWater(){

              System.out.println("Boiling Water");

       }

       void pourInCup(){

              System.out.println("Pouring into cup");

       }

}

public class Coffee extends CaffeineBeverage {

       @Override

       void brew() {

              System.out.println("Dripping Coffee through Filter");

       }

       @Override

       void addCondiments() {

              System.out.println("Adding Sugar and Milk");

       }

}

public class Tea extends CaffeineBeverage{

       public void brew(){

              System.out.println("Steeping the tea");

       }

       public void addCondiments(){

              System.out.println("Adding Lemon");

       }

}

Java 8 : Default methods, Optional and Logging

Default methods

Shortcomings of Interface:

The biggest disadvantage of using an interface is suppose you want add an new functionality to it, then all the classes that implement this interface needs to update the new functionality and  hence to avoid this Java8 has allowed to add default methods to the interfaces. The default method looks like below.

default void sort(Comparator<? super E> c){

          Collections.sort(this,c);

}

Difference between Abstract Class and Java 8 interface:

1. A Class can extend only one abstract class but whereas it can implement multiple interfaces.
2. An abstract class can interface a common state throughout i.e it has the instance variables but whereas the interface does not.

Note : The default methods are like the abstract methods defined in the interface but with the implementation and these are not static.

As part of Java 8 we can now have static and default methods in the in interface. PFB the example.

public interface A {

       static void helloStatic(){

              System.out.println("Hello from Static A");

       }

       default void hello(){

              System.out.println("Hello from A");

       }

}

Important Points:

1. All the methods defined in interface are public i.e the default and static methods both are public.
2. The default is not a access modifier, but its a keyword which is used on a method in a interface which says that its the implemented method in the interface.Note: Even out of the 4 access modifiers public,default,protected and private we never write a method with the default access modifier, but we do not specify any access modifier and it means the default one.

Lets discuss on the different cases on multiple inheritance.

Case 1:

public interface A {

       default void hello(){

              System.out.println("Hello from A");

       }

}

public interface B extends A{

       default void hello(){

              System.out.println("Hello from B");

       }

}

public class C implements B , A {

       public static void main(String[] args) {

              new C().hello();

       }

}

O/P is :Hello from B

Case 2:

public class D implements A {

}

O/P is :Hello from B

Case 3:

public class D implements A {

       public void hello(){

              System.out.println("Hello from D");

       }

}

O/P is :Hello from D

Case 4:

public class C extends D implements B , A {

       public void hello(){

              System.out.println("Hello from C");

       }

       public static void main(String[] args) {

              new C().hello();

       }

}

O/P is :Hello from C

Case 5:

public interface A {

       default void hello(){

              System.out.println("Hello from A");

       }

}

public interface B {

       default void hello(){

              System.out.println("Hello from B");

       }

}

public class C implements B , A {

       public static void main(String[] args) {

              new C().hello();

       }

}

This would through an compile time error because at complie time it does not know which method it should override and hence we would need to add a overridden method is C.

public class C implements A , B {

       public void hello(){

              System.out.println("Hello from C");

       }

       public static void main(String[] args) {

              new C().hello();

       }

}

On adding this it would work fine.

Case 6:

public interface A {

      default void hello(){

              System.out.println("Hello from A");

       }

}

public interface B extends A{

       void hello();

}

public class implements A , B {

       public static void main(String[] args) {

              new C().hello();

       }

}

O/P is: This would throw an compilation error to implement the hello method is C. Always remember that whenever is define an abstract method in interface it needs to be implemented in its child classes.

Case 7:

public interface A {

       void hello();

}

public interface B extends A{

      default void hello(){

              System.out.println("Hello from A");

       }

}

public class implements A , B {

       public static void main(String[] args) {

              new C().hello();

       }

}

O/P is: This would compile and execute fine.

Based on the above cases, the working of the overridden method can be taught as below:

1.Methods defined in the class or one defined in the inherited class or the sub class gets the preferance first. Ex: Case 3

2.The sub-interfaces win and if they are methods with the same signature then the most default one is selected. Ex: Case 1

3.Finally if the choice is still ambiguous then the class needs to explicitly select the default method by overriding it and calling the desired method.

Optional:

One of the challenges with the code is to check a variable if it is null everytime we want to perform any operation on it in order to avoid the NullPointerException. To counter this Java 8 has introduced the Optional.

Creating an Optional Objects:

1.Empty Optional: You can get an empty Optional object using the below code.

Optional<Car> optCar = Optional.empty();

2.Optional from a non null value:

Optional<Car> optCar = Optional.of(car);

If the car is null, a nullpointer error is thrown instead of throwing at the end and failing.

3.Optional from null

Optional<Car> optCar = Optional.ofNullable(car);

If the car is null then the resulting Optional object would be empty.

4.Extracting values using a map:

public class Person {

       private Optional<Car> car;

       public Optional<Car> getCar() {

              return car;

       }

}

public class Car {

       private Optional<Insurance> insurance;

       public Optional<Insurance> getInsurance() {

              return insurance;

       }

}

public class Insurance {

       private String name;

       public String getName() {

              return name;

       }

}

Optional<Insurance> optInsurance = Optional.ofNullable(insurance);

Optional<String> name = optInsurance.map(Insurance::getName);

This is similar to the Stream API but instead of many values, here it has a single element.

Chaining Optional Objects with flatMap:

We can get the values using the flatMap.The flatMap works same as it worked in stream.

       public static void main(String[] args) {

              Person person = new Person();

              Car car = new Car();

              Insurance insurance = new Insurance();

              insurance.setName("PQR");

              Optional<Insurance> optInsurance = Optional.ofNullable(insurance);

              car.setInsurance(optInsurance);

              Optional<Car> optCar = Optional.ofNullable(car);

              person.setCar(optCar);

              Optional<Person> optPerson = Optional.ofNullable(person);

              System.out.println(optPerson.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName().get());

       }

We can also provide a default value using the orElse.

System.out.println(optPerson.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

Serialization using Optional:

It does not support serialization and in order to use it for serialization we can use it as below.

public class Person {

       private Car car;

       public Optional<Car> getCar() {

              return Optional.ofNullable(car);

       }

}

Filtering using Optional:

Similar to stream we can filter the values from the Optional.

System.out.println(optInsurance.filter(insurance1 -> "PQR".equals(insurance1.getName()))

Summary : Important methods in Optional.

1. empty : This returns an empty Optional instance.
2. filter : If the value is present returns an Optional or else returns an empty.
3. flatMap : This would flat the structure Optional<Optional<String>> to Optional<String>.
4. get :  Returns the value in Optional instance or else gives a NosuchElementException and hence this should not be used v ery oftenly.
5. ifPresent : if the value is present then invokes the Consumer that is provided to it otherwise does nothing.
6. isPresent : Returns true if there is a value present else returns false.
7. map : if the value is present applies the corresponding map function. 
8. of : Returns an Optional wrapping the value or else throws a NullPointer Exception.
9. ofNullable : Returns an Optional wrapping the value else empty Optional if the value is null.
10. orElse : Returns the value if present or the given default values.
11. orElseGet : This is the lazy counterpart of orElse.
12. orElseThrow : Its similar to get but in case it allows you to select the type of exception you want to throw.

Logging:

 In Java 8 we can log the processing of the stream using the peek method.

public static void main(String[] args) {

List<Integer> result = Stream.of(2, 3, 4, 5)

.peek(x -> System.out.println("taking from stream: " + x)).map(x -> x + 17)

.peek(x -> System.out.println("after map: " + x)).filter(x -> x % 2 == 0)

.peek(x -> System.out.println("after filter: " + x)).limit(3)

.peek(x -> System.out.println("after limit: " + x)).collect(toList());

}