Java 8 Quick Recap

1.) What is Optional? Why and how can you use it?

Java 8 has introduced new class Called Optional. This class is basically introduced to avoid NullPointerException in java.
Optional class encapsulates optional value which is either present or not.
It is a wrapper around object and can be use to avoid NullPointerExceptions.
Let’s take a simple example. You have written below function to get first non repeated character in String.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public static Character getNonRepeatedCharacter(String str) {     Map<Character, Integer> countCharacters = new LinkedHashMap<Character, Integer>();           for (int i = 0; i < str.length() - 1; i++) {            Character c = str.charAt(i);            if (!countCharacters.containsKey(c)) {             countCharacters.put(c, 1);            } else {             countCharacters.put(c, countCharacters.get(c) + 1);            }           }           // As LinkedHashMap maintains insertion order, first character with           // count 1 should return first non repeated character           for (Entry<Character, Integer> e : countCharacters.entrySet()) {            if (e.getValue() == 1)             return e.getKey();             }           return null;            }

You call above method as below.

1 2 3 4

Character c=getNonRepeatedCharacter("SASAS");     System.out.println("Non repeated character is :"+c.toString());

Do you see the problem, there is no non repeating character for getNonRepeatedCharacter("SASAS") hence it will return null and we are calling c.toString(), so it will obviously throw NullPointerException.
You can use Optional to avoid this NullPointerException.
Let’s change the method to return Optional object rather than String.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public static Optional<Character> getNonRepeatedCharacterOpt(String str) {           Map<Character, Integer> countCharacters = new LinkedHashMap<Character, Integer>();           for (int i = 0; i < str.length(); i++) {            Character c = str.charAt(i);            if (!countCharacters.containsKey(c)) {             countCharacters.put(c, 1);            } else {             countCharacters.put(c, countCharacters.get(c) + 1);            }           }           // As LinkedHashMap maintains insertion order, first character with           // count 1 should return first non repeated character           for (Entry<Character, Integer> e : countCharacters.entrySet()) {            if (e.getValue() == 1)             return Optional.of(e.getKey());             }           return Optional.ofNullable(null);            }

When above method returned Optional, you are already aware that it can return null value too.
You can call Optional’s isPresent method to check if there is any value wrapped in Optional.

1 2 3 4 5 6 7 8 9

Optional<Character> opCh=getNonRepeatedCharacterOpt("SASAS");         if(opCh.isPresent())             System.out.println("Non repeated character is :"+opCh.toString());         else         {             System.out.println("No non repeated character found in String");         }

If there is no value present in Optional, it will simply print "No non repeated character found in String".

2.) Given the list of employee, group them by employee name?

You can use Collections.groupBy() to group list of employees by employee name.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

package org.arpit.java2blog;   import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.stream.Collectors;   public class MaximumUsingStreamMain {     public static void main(String args[])     {         List<Employee> employeeList = createEmployeeList();         Map<String, List<Employee>> map = employeeList.stream()                                               .collect(Collectors.groupingBy(Employee::getName));         map.forEach((name,employeeListTemp)->System.out.println("Name: "+name+" ==>"+employeeListTemp));     }       public static List<Employee> createEmployeeList()     {         List<Employee> employeeList=new ArrayList<>();           Employee e1=new Employee("John",21);         Employee e2=new Employee("Martin",19);         Employee e3=new Employee("Mary",31);         Employee e4=new Employee("Mary",18);         Employee e5=new Employee("John",26);           employeeList.add(e1);         employeeList.add(e2);         employeeList.add(e3);         employeeList.add(e4);         employeeList.add(e5);           return employeeList;     } }

Output:

Name: John ==>[Employee Name: John age: 21, Employee Name: John age: 26] Name: Martin ==>[Employee Name: Martin age: 19] Name: Mary ==>[Employee Name: Mary age: 31, Employee Name: Mary age: 18]

3.) Difference between Intermediate and terminal operations in Stream?

Filter(Predicate<T>) - Allows selective processing of Stream elements. It returns elements that are satisfying the supplied condition by the predicate.

map(Funtion<T, R>) - Returns a new Stream, transforming each of the elements by applying the supplied mapper function.= sorted() - Sorts the input elements and then passes them to the next stage.

distinct() - Only pass on elements to the next stage, not passed yet.

limit(long maxsize) - Limit the stream size to maxsize.

skip(long start) - Skip the initial elements till the start.

peek(Consumer) - Apply a consumer without modification to the stream.

flatMap(mapper) - Transform each element to a stream of its constituent elements and flatten all the streams into a single stream.

most common type of Terminal operations?

• collect() - Collects single result from all elements of the stream sequence.
• reduce() - Produces a single result from all elements of the stream sequence
  • count() - Returns the number of elements on the stream.
  • min() - Returns the min element from the stream.
  • max() - Returns the max element from the stream.
• Search/Query operations
  • anyMatch() , noneMatch() , allMatch() , ... - Short-circuiting operations.
  • Takes a Predicate as input for the match condition.
  • Stream processing will be stopped, as and when the result can be determined.
• Iterative operations
• forEach() - Useful to do something with each of the Stream elements. It accepts a consumer.
• forEachOrdered() - It is helpful to maintain order in parallel streams.

4.) Why do we need default methods in java

This is for backwards compatibility.

If you have an interface that other people have implemented then if you add a new method to the interface all existing implementations are broken.

By adding a new method with a default implementation you remaining source-compatible with existing implementations.

For a slightly simple/contrived example that should hopefully demonstrate this let us say you created a library:

void drawSomething(Thing thing) {
}

interface Thing {
    Color getColor();
    Image getBackgroundImage();
}

Now you come to do a new version of your library and you want to add the concept of border colors, that's easy to add to the interface:

interface Thing {
    Color getColor();
    Color getBorderColor();
    Image getBackgroundImage();
}

But the problem is that every single person using your library has to go back through every single Skin implementation they ever did and add this new method.

If instead you provided a default implementation to getBorderColor that just called getColor then everything "just works".