Function Interface in Java

Quick check before the theory: what does f1.andThen(f2).compose(f3).compose(f4).apply("Compose") print if every function appends its own digit to the string? Intuition says Compose1234. The console prints Compose4312. Chaining order is where Function trips people up most often, both in code and in interviews, so we will take that chain apart step by step below.

java.util.function.Function<T, R> is a built-in functional interface from the java.util.function package, added in Java SE 8. It takes one argument of type T and returns a result of type R — the same type or a different one. In other words, it describes a transformation of one value into another.

What the Function interface is

The declaration in the JDK looks like this:

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

It has exactly one abstract method, apply(), which is why it carries the @FunctionalInterface annotation and can be implemented with a lambda expression or a method reference.

The functional descriptor of the interface is:

T -> R

Read it as "one value of type T goes in, one value of type R comes out". Typical jobs: String to Integer, entity to DTO, id to object, number to a formatted string.

The apply() method

apply() is the single abstract method of the interface. Its body is what you write inside the lambda, and it performs the actual transformation. Here Exam objects are turned into a String:

public class Exam {
    private final String name;
    private final String version;

    public Exam(String name, String version) {
        this.name = name;
        this.version = version;
    }

    public String getName() {
        return name;
    }

    public String getVersion() {
        return version;
    }
}

Function<Exam, String> converter = e -> e.getName() + " " + e.getVersion();

System.out.println(converter.apply(new Exam("Java Core", "8")));
System.out.println(converter.apply(new Exam("Java Core", "17")));
System.out.println(converter.apply(new Exam("Java Core", "21")));

The output is:

Java Core 8
Java Core 17
Java Core 21

A second example is worth a closer look, because three implicit conversions happen in a single line:

import java.util.function.Function;

public class FunctionExample1 {
    public static void main(String[] args) {
        Function<Double, Long> rounder = d -> Math.round(d);
        System.out.println(rounder.apply(5.7)); // 6
    }
}

• the literal 5.7 (a double) is autoboxed into Double, because apply() accepts an object;
• inside the lambda that Double is unboxed back to double so that Math.round(double) can be called;
• the resulting long is boxed into Long, because the second type parameter is declared as Long.

The same lambda can be written as a method reference — the compiler picks the Math.round(double) overload because the target type demands a Long result:

Function<Double, Long> rounder = Math::round;
System.out.println(rounder.apply(5.7)); // 6

andThen and compose: execution order

Besides apply() the interface declares two default methods that glue functions into a chain:

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before);

The only difference between them is which function runs first:

Here is the chain from the opening question, plus a plain andThen chain for contrast:

import java.util.function.Function;

public class FunctionExample2 {
    public static void main(String[] args) {
        Function<String, String> f1 = s -> s + "1";
        Function<String, String> f2 = s -> s + "2";
        Function<String, String> f3 = s -> s + "3";
        Function<String, String> f4 = s -> s + "4";

        System.out.println(f1.andThen(f2).compose(f3).compose(f4).apply("Compose")); // Compose4312
        System.out.println(f1.andThen(f2).andThen(f3).apply("AndThen"));             // AndThen123
    }
}

The first line breaks down as follows. Every compose pushes a function to the front of the chain, so the function attached last is the one executed first:

The second line is simpler: andThen appends to the end of the chain, so execution order matches the order you wrote — f1, f2, f3 — and the result is AndThen123.

Function.identity()

The interface also declares one static method:

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

It returns a function that gives back its own argument unchanged — the identity transformation T -> T:

import java.util.function.Function;

public class FunctionExample3 {
    public static void main(String[] args) {
        Function<String, String> f = Function.identity();
        System.out.println(f.apply("Some Value")); // Some Value
    }
}

On its own such a call is useless. identity() earns its keep where an API demands a function but you need the original object as is — for example when the element itself becomes the map key:

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class IdentityExample {
    public static void main(String[] args) {
        List<String> words = List.of("Java", "Function", "Lambda");

        Map<String, Integer> lengthByWord = words.stream()
                .collect(Collectors.toMap(Function.identity(), String::length));

        System.out.println(lengthByWord); // {Java=4, Lambda=6, Function=8}
    }
}

Where Function shows up in the JDK

Function is the most widely used functional interface in the standard library. The entry points you will meet first:

• Stream.map(Function<? super T, ? extends R>) — transform every element of a stream;
• Optional.map(Function<? super T, ? extends U>) — transform the value if one is present;
• Map.computeIfAbsent(K, Function<? super K, ? extends V>) — compute a value for a missing key;
• Collectors.toMap and Collectors.groupingBy — extract a key from an element;
• Comparator.comparing(Function<? super T, ? extends U>) — sort by a derived field.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

public class FunctionInApi {
    public static void main(String[] args) {
        Function<String, Integer> length = String::length;

        // 1. Stream.map accepts a Function
        List<Integer> lengths = List.of("Java", "Function", "Lambda")
                .stream()
                .map(length)
                .toList(); // Stream.toList() is available since Java 16
        System.out.println(lengths); // [4, 8, 6]

        // 2. Map.computeIfAbsent: the Function builds the value for a new key
        Map<Character, List<String>> byFirstLetter = new HashMap<>();
        for (String word : List.of("Java", "Jar", "Lambda")) {
            byFirstLetter.computeIfAbsent(word.charAt(0), k -> new ArrayList<>()).add(word);
        }
        System.out.println(byFirstLetter); // {J=[Java, Jar], L=[Lambda]}
    }
}

BiFunction, UnaryOperator and primitive variants

The plain Function<T, R> works with objects only and takes exactly one argument. For everything else the java.util.function package ships ready-made specializations:

Function, Supplier, Consumer and Predicate

Function is one of the four core functional interfaces in java.util.function. The easiest way to tell them apart is by asking whether they have an input and an output:

Technically Predicate<T> could be replaced by Function<T, Boolean>, but you should not: Predicate returns a primitive boolean with no boxing and adds and(), or() and negate().

Where developers get tripped up

• Mixing up compose and andThen. The single most common mistake, in code and in interviews alike. compose runs the argument function before the current one; andThen runs it after.
• Expecting Function to modify the original object. A function changes nothing in place — it returns a new value. A bare converter.apply(x); without assigning the result does nothing useful.
• Trying to throw a checked exception. apply() is declared without throws, so an IOException inside the lambda will not compile; you have to catch it and wrap it in an unchecked exception.
• Using the object flavour for numbers. Function<Integer, Integer> in a million-iteration loop creates a million boxed values; IntUnaryOperator creates none.
• Forgetting about null. Function knows nothing about null: if apply() receives null and the lambda calls a method on it, you get a NullPointerException. Guard it yourself or use Optional.map.

The official reference with every signature is in the Javadoc for java.util.function.Function.