{"id":79193,"date":"2020-06-30T09:00:28","date_gmt":"2020-06-30T03:30:28","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=79193"},"modified":"2020-06-30T09:00:28","modified_gmt":"2020-06-30T03:30:28","slug":"functional-interface-in-java","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/functional-interface-in-java\/","title":{"rendered":"Functional Interface in Java"},"content":{"rendered":"

In our last article, we discussed the Reflection API in Java. In this article, we will discuss the Functional interface in Java and @FunctionalInterface Annotation in Java. Within@FunctionalInterface Annotation, we will discuss the Java.util.function package with examples.<\/p>\n

We will also discuss Lambda Expression in the Java programming language.<\/p>\n

Functional Interface in Java<\/h3>\n

A functional interface is an interface in which there is only one abstract method. A functional interface has only one functionality to exhibit. From Java 8 onwards, we can use lambda expressions to represent the instance of a functional interface.<\/p>\n

There can be any number of default and static methods in a functional interface that have an implementation. Some of the examples of functional interfaces in Java are Runnable, ActionListener, Comparable interfaces.<\/p>\n

We had to use anonymous inner class objects to implement functional interfaces before Java 8.<\/p>\n

Rules of defining a Functional Interface<\/h3>\n

The functional interface must have only one abstract method. Along with the one abstract method, they can have any number of default and static methods.<\/p>\n

Examples of Functional Interface<\/h3>\n

The example of functional interface example in Java is:<\/p>\n

public interface MyFunctionalInterface {\n  public void mymethod();\n}<\/pre>\n
The above example shows a functional interface because it only contains a single method that has no implementation.<\/p>\n
Following code snippet is another example of a Java functional interface that has an implementation of some methods:<\/p>\n
public interface MyFunctionalInterface {\n  public void myMethod();\n\n  public default void printText(String text) {\n    System.out.println(text);\n  }\n\n  public static void printText(String text, PrintWriter writer) throws IOException {\n    writer.write(text);\n  }\n}<\/pre>\n
The above interface is a functional interface because it only contains a single non-implemented method.<\/p>\n
Implementation of Functional Interfaces by a Lambda Expression in Java<\/h3>\n
Lambda Expressions in Java are the way through which we can visualize functional programming in the object-oriented world. Objects are the basic building block of Java programming language and we can never use a function without an object.<\/p>\n
Therefore, Java provides support for using lambda expressions only with functional interfaces. We can implement a Java functional interface using Java Lambda Expression.<\/p>\n
Examples of Java Lambda Expressions<\/h4>\n
Below are some code snippets for lambda expressions with small comments explaining them.<\/p>\n\n\n\n\n\n\n\n
() -> {}\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nNo parameters; void result<\/span><\/td>\n<\/tr>\n
() -> 42\u00a0\u00a0<\/span><\/td>\nNo parameters, expression body<\/span><\/td>\n<\/tr>\n
\u00a0 () -> null\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nNo parameters, expression body<\/span><\/td>\n<\/tr>\n
 () -> { return 42; }\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nNo parameters, block body with return<\/span><\/td>\n<\/tr>\n
 () -> { System.gc(); }\u00a0<\/span><\/td>\nNo parameters, void block body<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n\n\n\n\n\n\n
(int x) -> x+1\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nSingle declared-type argument<\/span><\/td>\n<\/tr>\n
(int x) -> { return x+1; }<\/span><\/td>\nsame as above<\/span><\/td>\n<\/tr>\n
(x) -> x+1\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nSingle inferred-type argument, same as below<\/span><\/td>\n<\/tr>\n
\u00a0 x -> x+1\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nParentheses optional for single inferred-type case<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n\n\n\n\n\n\n
(String s) -> s.length()\u00a0\u00a0<\/span><\/td>\nSingle declared-type argument<\/span><\/td>\n<\/tr>\n
 (Thread t) -> { t.start(); }\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nSingle declared-type argument<\/span><\/td>\n<\/tr>\n
s -> s.length()\u00a0\u00a0\u00a0<\/span><\/td>\nSingle inferred-type argument<\/span><\/td>\n<\/tr>\n
t -> { t.start(); }\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nSingle inferred-type argument<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n\n\n\n\n\n\n
(int x, int y) -> x+y\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nMultiple declared-type parameters<\/span><\/td>\n<\/tr>\n
(x,y) -> x+y\u00a0\u00a0<\/span><\/td>\nMultiple inferred-type parameters<\/span><\/td>\n<\/tr>\n
(x, final y) -> x+y\u00a0\u00a0<\/span><\/td>\nIllegal: can’t modify inferred-type parameters<\/span><\/td>\n<\/tr>\n
(x, int y) -> x+y\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/td>\nIllegal: can’t mix inferred and declared types<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Program to Implement Java Functional Interface using Lambda Expressions<\/h3>\n
\/\/Java program to implement the functional interface using lambda expressions\npublic class Example {\n  public static void main(String args[]) {\n    \/\/lambda expression to create the object\n    new Thread(() - >{\n      System.out.println(\"Created a new thread\");\n    }).start();\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Created a new thread<\/div>\n
Why do we need Lambda Expression?<\/h4>\n
We need to use Lambda Expressions due to following reasons:<\/p>\n
1. Reduced Lines of Code<\/h5>\n
Reduced lines of code is one of the clear benefits of using a lambda expression. We can create instances of a functional interface using lambda expression rather than using an anonymous class.<\/p>\n
2. Sequential and Parallel Execution Support<\/h5>\n
Another advantage of using lambda expression is that we can get a Stream API sequential and parallel execution support.<\/p>\n
3. Passing Behaviors into methods<\/h5>\n
We can use lambda expressions to pass the behavior of a method. Let\u2019s understand this with a simple example. Suppose, we have to write a method to sum the numbers in a list if they match the given condition.<\/p>\n
We can use the Predicate interface and write a method like below.<\/p>\n
public static int sumWithCondition(List < Integer > numbers, Predicate < Integer > predicate) { \n    return numbers.parallelStream().filter(predicate).mapToInt(i - >i).sum();\n}<\/pre>\n
For example:<\/strong><\/p>\n
\/\/sum of all numbers\nsumWithCondition(numbers, n - >true)\n\/\/sum of all even numbers\nsumWithCondition(numbers, i - >i % 2 == 0)\n\/\/sum of all numbers greater than 5\nsumWithCondition(numbers, i - >i > 5)<\/pre>\n
4. Higher Efficiency with Laziness<\/h5>\n
Lambda expressions provide a lazy evaluation with higher efficiency. For example, suppose, we have to write a method to find out the maximum odd number in the range 4 to 15 and return the square of it. Using Lambda expression, we can write the code like this:<\/p>\n
public static int findSquareOfMaxOdd(List < Integer > numbers) {\n  return numbers.stream().filter(NumberTest::isOdd)\n  \/\/Predicate is functional interface and\n  .filter(NumberTest::isGreaterThan4)\n  \/\/ we are using lambdas to initialize it\n  .filter(NumberTest::isLessThan15)\n  \/\/ rather than anonymous inner classes\n  .max(Comparator.naturalOrder()).map(i - >i * i).get();\n}\npublic static boolean isOdd(int i) {\n  return i % 2 != 0;\n}\npublic static boolean isGreaterThan4(int i) {\n  return i > 4;\n}\npublic static boolean isLessThan15(int i) {\n  return i < 15;\n}<\/pre>\n
@FunctionalInterface Annotation<\/h3>\n
We can use the @FunctionalInterface annotation to ensure that there is not more than one abstract method in a functional interface.<\/p>\n
In case if there is more than one abstract method in the functional interface, the compiler gives an \u2018Unexpected @FunctionalInterface annotation\u2019 message. However, there is no compulsion to use this annotation.<\/p>\n
Code to understand @FuctionalInterface Annotation in Java:<\/strong><\/p>\n
\/\/Program to implement a user-defined functional interface using lambda expressions\n@FunctionalInterface\ninterface Square {\n  int calculateSquare(int x);\n}\npublic class Test {\n  public static void main(String args[]) {\n    int num = 10;\n\n    \/\/lambda expression to define the calculate method\n    Square sq = (int x) - >x * x;\n    int answer = sq.calculateSquare(num);\n    System.out.println(\"The square of the number is: \" + answer);\n  }\n}<\/pre>\n
Output:<\/strong><\/p>\n
The square of the number is: 100<\/div>\n
Primitive Function Specializations<\/h3>\n
We know that primitive types cannot be a generic type argument. Therefore, there are versions of the Functional interface for some primitive types such as double, int, long, and their combinations in return types and argument:<\/p>\n