New features of Java 8?

Following are new introduces features of java8

Functional interface

Functional interface is single abstract method interface having only one abstract value but multiple default and static method.
it use lembda expression for implimentation which reduce the length of code and create expression based structure.

@FunctionalInterface annotation is used in order to strict follow but it is not necessary for application
Some predefined functional interface are present before only are –
Runnable, ActionListener, Comparable .
Newly introduced functional interfaces are –
predicate ,consumer and supplier, function

Difference between Predicate and function

Difference between Static and Default

what is Optional Class in java?

Optional classes are public final classes that is used to deal with null pointer exception in java8

import java.util.Optional;
                public class OptionalClasses {
                    public static void main(String[] args) {
                        String[] str = new String[10];
                        Optional op = Optional.ofNullable(str[5]);
                        if (op.isPresent()) {
                            String st = str[5].toString();
                            System.out.println(st);
                        } else {
                            System.out.println(“No string”);
                        }
                    }
                }

Define Date and time API

For current date we can use it
            LocalDate d = localDate.now();
            System.out.println(dt);

For current date and time we can use it
                Localdateandtime dt = Localdateandtime.now();
                System.out.println(dt);

For current date and time we can use it
                    Localtime t = Localtime.now();
                    System.out.println(t);

Different function of Date and Time api

import java.time.LocalDate;
            import java.time.LocalDateTime;
            import java.time.LocalTime;
            import java.time.ZoneId;
            import java.time.ZonedDateTime;
            import java.util.Set;
            
            
            public class DateANdTime {
                public static void main(String[] args) {
                    LocalDate date = LocalDate.now();
                    System.out.println(date);
                    LocalTime time = LocalTime.now();
                    System.out.println(time);
                    LocalDateTime current = LocalDateTime.now();
                    System.out.println(current);
                    ZonedDateTime xx = ZonedDateTime.now();
                    System.out.println(xx);
                    Set < String > zone = ZoneId.getAvailableZoneIds();
                    System.out.println(zone + " \n");
                    ZonedDateTime xxc = ZonedDateTime.now(ZoneId.of("America/New_York"));
                    System.out.println(xxc);
                }
            }

Steam Api

Stream represents a sequence of objects from a source such as a collection,
which supports aggregate operations.
They were designed to make collection processing simple and concise

Difference between Intermediate and Terminal

Difference between map vs Flatmap

Difference between Collection and Steam

Difference between Iterator vs Splitor

StringJoiner in Java8

Joining the strings or concatenating the strings is the frequent
operation while programming any kind of applications.

StringJoiner Example : Joining the strings with delimiter

import java.util.StringJoiner;
 
            public class Java8StringJoiner 
            {
                public static void main(String[] args) 
                {
                    StringJoiner stringJoiner = new StringJoiner(" | ");
                     
                    stringJoiner.add("Facebook");
                     
                    stringJoiner.add("Twitter");
                     
                    stringJoiner.add("YouTube");
                     
                    stringJoiner.add("WhatsApp");
                     
                    stringJoiner.add("LinkedIn");
                     
                    System.out.println(stringJoiner);
                }
            }
            Output :
            
            Facebook | Twitter | YouTube | WhatsApp | LinkedIn

StringJoiner Example : Joining the strings with delimiter, prefix and suffix

import java.util.StringJoiner;
 
                public class Java8StringJoiner 
                {
                    public static void main(String[] args) 
                    {
                        StringJoiner stringJoiner = new StringJoiner(", ", "[", "]");
                         
                        stringJoiner.add("Facebook");
                         
                        stringJoiner.add("Twitter");
                         
                        stringJoiner.add("YouTube");
                         
                        stringJoiner.add("WhatsApp");
                         
                        stringJoiner.add("LinkedIn");
                         
                        System.out.println(stringJoiner);
                    }
                }
                
                Output :
                
                [Facebook, Twitter, YouTube, WhatsApp, LinkedIn]

String.join() Method Example : Joining the strings

public class Java8StringJoinMethod 
                    {
                        public static void main(String[] args) 
                        {
                            String joinedString = String.join(" | ", "Facebook", "Twitter", "YouTube", "WhatsApp", "LinkedIn");
                             
                            System.out.println(joinedString);
                        }
                    }
                    
                    Output :
                    
                    Facebook | Twitter | YouTube | WhatsApp | LinkedIn

String.join() Method Example : Joining an array of strings

public class Java8StringJoinMethod 
                        {
                            public static void main(String[] args) 
                            {
                                String[] strArray = new String[] {"Facebook", "Twitter", "YouTube", "WhatsApp", "LinkedIn"};
                                 
                                String joinedString = String.join(" | ", strArray);
                                 
                                System.out.println(joinedString);
                            }
                        }
                        
                        Output :
                        
                        Facebook | Twitter | YouTube | WhatsApp | LinkedIn

String.join() Method Example : Joining list of strings

import java.util.Arrays;
                            import java.util.List;
                             
                            public class Java8StringJoinMethod 
                            {
                                public static void main(String[] args) 
                                {
                                    List<String> listOfStrings = Arrays.asList("Facebook", "Twitter", "YouTube", "WhatsApp", "LinkedIn");
                                     
                                    String joinedString = String.join(" | ", listOfStrings);
                                     
                                    System.out.println(joinedString);
                                }
                            }
                            
                            output:
                            Facebook | Twitter | YouTube | WhatsApp | LinkedIn

What is Method Reference

Method reference used to refer to the method of functional interface.
It can be used to replace Lambda Expression while referring to a method.

import java.util.function.Function;

                public class Java8MethodReferences {
                    public static void main(String[] args) {
                        //Calling parseInt() method using lambda
                
                        Function < String, Integer > lambdaFunction = (String s) - > Integer.parseInt(s);
                        System.out.println(lambdaFunction.apply("12"));
                
                        //Calling parseInt() method using method reference
                
                        Function < String, Integer > referenceFunction = Integer::parseInt;
                        System.out.println(referenceFunction.apply("12"));
                    }
                }