What’s new in Java 8

Reading Time: 3 minutes

Let’s have a brief look on these Java 8 features. I will provide some code snippets for better understanding the features in a simple way.

Some of the important Java 8 features are;

1. Lambda expressions
2. Method references
3. Functional Interfaces

1. Lambda expressions

• Lambda expression helps us to write our code in functional style.
• These are just like functions and they accept parameters just like functions.
• It is an anonymous function, no function name and no method return type.
• The body of a lambda expression can contain zero, one or more statements.
• It saves a lot of code, we don’t need to define the method again for providing the implementation.

Syntax:-

lambda operator -> body

Example:-

() -> System.out.println("lambda expression simplest example");

2. Method references

• Method reference is used to refer method of functional interface.
• It is compact and easy form of lambda expression.
• Each time when you are using lambda expression to just refering a method, you can replace your lambda expression with method reference.

Types of method References are given below:-

1. Method reference to static method

@FunctionalInterface
public interface Walkable {
    public abstract void walk();
}

public class Sample {
    public static void walking() {
        System.out.println(“Hey, lets go to walk”);
    }


}

public class MainClass {
    public static void main(String[] args) {

        //Lambda Expression
        //Walkable walkable=()->System.out.println(“Hey, lets go to walk”);

        // Replaced above Lambda Expression with Method Reference
        Walkable walkable = Sample::walking;
        walkable.walk();

    }
}

Output:

Hey, lets go to walk

2. Method reference to instance method of a particular object

@FunctionalInterface
public interface Welcome{
    String welcome(String name);
}

public class Sample {
    public String welcomeMessage(String name) {
        return “Hey:” + name;
    }


}

public class MainClass {
    public static void main(String[] args) {

        //Lambda Expression
        // Welcome welcome2=name -> “Hey:” + name;

        // Replaced above Lambda Expression with Method Reference
        Welcome welcome2=new Sample()::welcomeMessage;
        System.out.println(welcome2.welcome(“ABC”));

    }
}

Output:

Hey: ABC

3. Method reference to an instance method from class Type

public class Main {
    public static void main(String[] args) {
        List<String> nameList = new ArrayList<>();

        nameList.add("John");
        nameList.add("Tony");
        nameList.add("Abhay");
        nameList.add("Sam");
        nameList.add("Danny");

        //nameList.sort((s1,s2) -> s1.compareTo(s2));

        // Replaced Lambda Expression from above line to Method Reference
        nameList.sort(String::compareTo);
        nameList.forEach(System.out::println);

    }
}

Output:-

Abhay

Danny

John

Sam

Tony

4. Method reference to Constructor

@FunctionalInterface
public interface Welcome {
    public abstract void welcome();
}

public class Sample {
    //constructor
    Sample() {
        System.out.println(“Method reference to Constructor”);


    }


}

public class MainClass {
    public static void main(String[] args) {

        // Method Reference to constructor
        Welcome welcome2 = Sample::new;
        welcome2.Welcome();

    }
}

Output:

Method reference to Constructor

3. Functional Interfaces

• An interface which has only one abstract method is called Functional Interfaces.
• In short form, it is also called as SAM interface, means Single Abstract Method Interface.
• Runnable, ActionListener, Comparable are some of the examples of functional interfaces. 

Why Functional Interface?

• Functional interface is used for enabling functional programming to java language.
• It is also used for defining Lambda expressions to a function directly as argument to method.
• As we define LE from a FI, we can also define a Functional Interface is a Base type/ Super type of a Lambda Expression.

Syntax:

         interface <interface-name> {
		-one abstract method 
			}

Example:

@FunctionalInterface
interface Multiply
{
    int cal(int x);
}

public class Main {
    public static void main(String[] args) {

        int a = 5;

        // lambda expression to define the cal method
        Multiply mul = (int x)->x*x;

        //parameter passed and return type must be same as defined in the prototype
        int result = mul.cal(a);
        System.out.println(result);

        }
    }

Conclusion

There are many features that I didn’t cover in the article. You can find the whole list of changes by clicking here. Which features do you think are game-changers? Comment below and let us know!