RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/function-interface-in-java/ below:

Function Interface in Java - GeeksforGeeks

Function Interface in Java

Last Updated : 11 Jul, 2025

The Function Interface is a part of the java.util.function package that has been introduced since Java 8, to implement functional programming in Java. It represents a function that takes in one argument and produces a result. Hence, this functional interface takes in 2 generics, namely as follows:

T: denotes the type of the input argument
R: denotes the return type of the function

Note: The lambda expression assigned to an object of Function type is used to define its apply() which eventually applies the given function on the argument.

Methods in Function Interface

The Function interface consists of the following 4 methods, as listed, which are later discussed as follows:

apply()
andThen()
compose()
identity()

Method 1: apply()

Syntax:

R apply(T t)

Parameters: This method takes in only one parameter t, which is the function argument
Return Type: This method returns the function result, which is of type R.

Example:

Java


 // Java Program to Illustrate Functional Interface
// Via apply() method

// Importing interface
import java.util.function.Function;

// Main class
public class Geeks {

    // Main driver method
    public static void main(String args[])
    {
        // Function which takes in a number
        // and returns half of it
        Function<Integer, Double> half = a -> a / 2.0;

        // Applying the function to get the result
        System.out.println(half.apply(10));
    }
}

Method 2: andThen()

It returns a composed function wherein the parameterized function will be executed after the first one. If evaluation of either function throws an error, it is relayed to the caller of the composed function.

Syntax:

default <V> Function<T, V>

andThen(Function<? super R, ? extends V> after)

where V is the type of output of the after function, and of the composed function

Parameters: This method accepts a parameter after which is the function to be applied after the current one.
Return Value: This method returns a composed function that applies the current function first and then the after function

Exception: This method throws NullPointerException if the after function is null.

Example 1:

Java


 // Java Program to illustrate addThen() method

// Importing interface
import java.util.function.Function;

// Main class
public class Geeks {

    // main driver method
    public static void main(String args[])
    {
        // Function which takes in a number and
        // returns half of it
        Function<Integer, Double> half = a -> a / 2.0;

        // Now triple the output of half function
        half = half.andThen(a -> 3 * a);

        // Applying the function to get the result
        // and printing on console
        System.out.println(half.apply(10));
    }
}

Example 2: To demonstrate when NullPointerException is returned.

Java


 // Java Program to illustrate addThen() method
// When NullPointerException occurs

// Importing interface
import java.util.function.Function;

// Main class
public class Geeks {

    // Main driver method
    public static void main(String args[])
    {

        // Function which takes in a number and
        // returns half of it
        Function<Integer, Double> half = a -> a / 2.0;

        // Try block to check for exceptions
        try {

            // Trying to pass null as parameter
            half = half.andThen(null);
        }

        // Catch block to handle exceptions
        catch (Exception e) {

            // Print statement
            System.out.println("Exception thrown "
                               + "while passing null: "
                               + e);
        }
    }
}

Output

Exception thrown while passing null: java.lang.NullPointerException

Method 3: compose()

It returns a composed function wherein the parameterized function will be executed first and then the first one. If evaluation of either function throws an error, it is relayed to the caller of the composed function.

Syntax:

default <V> Function<V, R>

compose(Function<? super V, ? extends T> before)

Where V is the type of input of the before function, and of the composed function

Parameters: This method accepts a parameter before which is the function to be applied first and then the current one
Return Value: This method returns a composed function that applies the current function after the parameterized function

Exception: This method throws NullPointerException if the before function is null.

Example 1:

Java


 // Java Program to illustrate compose() method

// Importing Function interface
import java.util.function.Function;

// Main class
public class Geeks {

    // Main driver method
    public static void main(String args[])
    {
        // Function which takes in a number and
        // returns half of it
        Function<Integer, Double> half = a -> a / 2.0;

        // Triple the value given to half function
        half = half.compose(a -> 3 * a);

        // Applying the function to get the result
        System.out.println(half.apply(5));
    }
}

Example 2: When NullPointerException is returned.

Java


 // Java Program to illustrate compose() method

// Importing Function interface
import java.util.function.Function;

// Main class
public class Geeks {

    // Main driver method
    public static void main(String args[])
    {
        // Function which takes in a number and
        // returns half of it
        Function<Integer, Double> half = a -> a / 2.0;

        // Try block to check for exceptions
        try {

            // Trying to pass null as parameter
            half = half.compose(null);
        }

        // Catch block to handle exceptions
        catch (Exception e) {

            // Print statement
            System.out.println("Exception thrown "
                               + "while passing null: "
                               + e);
        }
    }
}

Output

Exception thrown while passing null: java.lang.NullPointerException

Method 4: identity()

This method returns a function that returns its only argument.

Syntax:

static <T> Function<T, T> identity()

where T denotes the type of the argument and the value to be returned.

Returns: This method returns a function that returns its own argument.

Example:

Java


 // Java Program to Illustrate identity() method

// Importing Function interface
import java.util.function.Function;

// Main class
public class Geeks {

    // Main driver method
    public static void main(String args[])
    {
        // Function which takes in a number and
        // returns it
        Function<Integer, Integer> i = Function.identity();

        System.out.println(i.apply(10));
    }
}

Applying Function on Objects and Handling Multiple Conditions

1. Using Function on Objects

Example:

Java


 // Demonstrates the working of functional interface
import java.util.function.Function;

// create a Person class with properties 
// name and age
class Person {
    String name;
    int age;
    
    // creates a constructor
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // override the toString() method to 
    // display the person details
    @Override
    public String toString() {
        return "Name: " + name + ", Age: " + age;
    }
}

public class Geeks {
    public static void main(String args[]) {
        
        // create a Function that takes object and 
        // returns a greeting with the person's name
        Function<Person, String> greet = person -> "Hello, " + person.name;

        Person p = new Person("Geek1", 25);
        System.out.println(greet.apply(p)); 
    }
}

Explanation: In the above example we are using a Function interface to transform the Person object into a greeting string which contains the person's name.

2. Handling Multiple Conditions Using Function

Example:

Java


 // Handling Multiple Conditions 
// with the help of Function
import java.util.function.Function;

public class Geeks {
    public static void main(String args[]) {
        Function<Integer, Integer> addFive = a -> a + 5;
        Function<Integer, Integer> multiplyByTwo = a -> a * 2;

        // Applying functions sequentially: Add five, then multiply by two
        Function<Integer, Integer> result = addFive.andThen(multiplyByTwo);

        System.out.println(result.apply(3));  
    }
}

Explanation: In the above example, two functions are declared with the help of Function interface. The first function takes an integer and add 5 to it and the second function takes an integer and then multiply it with 2. These two functions are combined with andThen() method. This method make sure that the addFive() function is applied first and then multipleByTwo() function is applied.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4