In our earlier post on Functional Interfaces in Java we saw how you can create custom functional interfaces and annotate them with the @FunctionalInterface Annotation. However, you don’t always need to define your own functional interface for every scenario. Java has introduced a new package java.util.function that defines many general purpose pre-defined functional interfaces.
These built-in interfaces are widely used across the JDK, including the Collections framework, Java Stream API and in user defined code as well.
In this guide, we’ll dive into these built-in functional interfaces in Java so you have a good idea which functional interface to use in which context while using with Lambda expressions in Java.
- Pre-defined functional interfaces categorization
- Consumer functional interface
- Consumer functional interface Java example
- Supplier functional interface
- Supplier functional interface example
- Function functional interface
- Function functional interface example
- Predicate functional interface
- Predicate functional interface Example
- Operator functional interfaces
- UnaryOperator functional interface Java example
Pre-defined functional interfaces categorization
Functional interfaces defined in java.util.function package can be categorized into five types-
- Consumer- Consumes the passed argument and no value is returned.
- Supplier- Takes no argument and supplies a result.
- Function- Takes argument and returns a result.
- Predicate- Evaluates a condition on the passed argument and returns a boolean result (true or false).
- Operators- A specialized form of Function where both input and output are of the same type.
Consumer functional interface
Consumer<T> represents a function that accepts a single input argument and returns no result. Consumer functional interface definition
is as given below consisting of an abstract method accept() and a default method andThen().
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
Following pre-defined Consumer functional interfaces are categorized as Consumer as all of these interfaces have the same behavior of consuming the passed value(s) and returning no result. You can use any of these based on number of arguments or data type.
- BiConsumer<T,U>- Represents an operation that accepts two input arguments and returns no result.
- DoubleConsumer- Represents an operation that accepts a single double-valued argument and returns no result.
- IntConsumer- Represents an operation that accepts a single int-valued argument and returns no result.
- LongConsumer- Represents an operation that accepts a single long-valued argument and returns no result.
- ObjDoubleConsumer<T>- Represents an operation that accepts an object-valued and a double-valued argument, and returns no result.
- ObjIntConsumer<T>- Represents an operation that accepts an object-valued and a int-valued argument, and returns no result.
- ObjLongConsumer<T>- Represents an operation that accepts an object-valued and a long-valued argument, and returns no result.
Consumer functional interface Java example
In the example elements of List are displayed by using an implementation of Consumer functional interface.
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class ConsumerExample {
public static void main(String[] args) {
Consumer<String> consumer = s -> System.out.println(s);
List<String> alphaList = Arrays.asList("A", "B", "C", "D");
for(String str : alphaList) {
// functional interface accept() method called
consumer.accept(str);
}
}
}
Output
A B C D
Supplier functional interface
Supplier<T> represents a function that doesn't take argument and supplies a result. Supplier functional interface definition is as given below consisting of an abstract method get()-
@FunctionalInterface
public interface Supplier<T> {
T get();
}
Following pre-defined Supplier functional interfaces are categorized as Supplier as all of these interfaces have the same behavior of supplying a result.
- BooleanSupplier- Represents a supplier of boolean-valued results.
- DoubleSupplier- Represents a supplier of double-valued results.
- IntSupplier- Represents a supplier of int-valued results.
- LongSupplier- Represents a supplier of long-valued results.
Supplier functional interface Java example
In the example Supplier functional interface is implemented as a lambda expression to supply current date and time.
import java.time.LocalDateTime;
import java.util.function.Supplier;
public class SupplierExample {
public static void main(String[] args) {
Supplier<LocalDateTime> currDateTime = () -> LocalDateTime.now();
System.out.println(currDateTime.get());
}
}
Function functional interface
Function<T,R> represents a function that accepts one argument and produces a result. Function functional interface definition is as given below consisting of an abstract method apply(), two default methods compose(), andThen() and a static method identity().
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
Following pre-defined Function functional interfaces are categorized as Function as all of these interfaces have the same behavior of accepting argument(s) and producing a result.
- BiFunction<T,U,R>- Represents a function that accepts two arguments and produces a result.
- DoubleFunction<R>- Represents a function that accepts a double-valued argument and produces a result.
- DoubleToIntFunction- Represents a function that accepts a double-valued argument and produces an int-valued result.
- DoubleToLongFunction- Represents a function that accepts a double-valued argument and produces a long-valued result.
- IntFunction<R>- Represents a function that accepts an int-valued argument and produces a result.
- IntToDoubleFunction- Represents a function that accepts an int-valued argument and produces a double-valued result.
- IntToLongFunction- Represents a function that accepts an int-valued argument and produces a long-valued result.
- LongFunction<R>- Represents a function that accepts a long-valued argument and produces a result.
- LongToDoubleFunction- Represents a function that accepts a long-valued argument and produces a double-valued result.
- LongToIntFunction- Represents a function that accepts a long-valued argument and produces an int-valued result.
- ToDoubleBiFunction<T,U>- Represents a function that accepts two arguments and produces a double-valued result.
- ToDoubleFunction<T>- Represents a function that produces a double-valued result.
- ToIntBiFunction<T,U>- Represents a function that accepts two arguments and produces an int-valued result.
- ToIntFunction<T>- Represents a function that produces an int-valued result.
- ToLongBiFunction<T,U>- Represents a function that accepts two arguments and produces a long-valued result.
- ToLongFunction<T>- Represents a function that produces a long-valued result.
Function functional interface Java example
In the example a Function interface is implemented to return the length of the passed String.
import java.util.function.Function;
public class FunctionExample {
public static void main(String[] args) {
Function<String, Integer> function = (s) -> s.length();
System.out.println("Length of String- " + function.apply("Interface"));
}
}
Output
Length of String- 9
Predicate functional interface
Predicate<T> represents a function that accepts one argument and produces a boolean result. Abstract method in the Predicate functional interface is boolean test(T t).
Following pre-defined Predicate functional interfaces are categorized as Predicate as all of these interfaces have the same behavior of accepting argument(s) and producing a boolean result.
- BiPredicate<T,U>- Represents a predicate (boolean-valued function) of two arguments.
- DoublePredicate- Represents a predicate (boolean-valued function) of one double-valued argument.
- IntPredicate- Represents a predicate (boolean-valued function) of one int-valued argument.
- LongPredicate- Represents a predicate (boolean-valued function) of one long-valued argument.
Predicate functional interface Java Example
In the example a number is passed and true is returned if number is even otherwise odd is retuned.
import java.util.function.Predicate;
public class PredicateExample {
public static void main(String[] args) {
Predicate<Integer> predicate = (n) -> n%2 == 0;
boolean val = predicate.test(6);
System.out.println("Is Even- " + val);
System.out.println("Is Even- " + predicate.test(11));
}
}
Output
Is Even- true Is Even- false
Operator functional interfaces
Operator functional interfaces are specialized Function interfaces that always return the value of same type as the passed arguments. Operator functional interfaces extend their Function interface counterpart like UnaryOperator extends Function and BinaryOperator extends BiFunction.
Following pre-defined Operator functional interfaces are there that can be used in place of Function interfaces if returned value is same as the type of the passed argument(s).
- BinaryOperator<T>- Represents an operation upon two operands of the same type, producing a result of the same type as the operands.
- DoubleBinaryOperator- Represents an operation upon two double-valued operands and producing a double-valued result.
- DoubleUnaryOperator- Represents an operation on a single double-valued operand that produces a double-valued result.
- IntBinaryOperator- Represents an operation upon two int-valued operands and producing an int-valued result.
- IntUnaryOperator- Represents an operation on a single int-valued operand that produces an int-valued result.
- LongBinaryOperator- Represents an operation upon two long-valued operands and producing a long-valued result.
- LongUnaryOperator- Represents an operation on a single long-valued operand that produces a long-valued result.
- UnaryOperator<T>- Represents an operation on a single operand that produces a result of the same type as its operand.
UnaryOperator functional interface Java example
In the example UnaryOperator is implemented to return the square of the passed integer.
import java.util.function.UnaryOperator;
public class UnaryOperatorExample {
public static void main(String[] args) {
UnaryOperator<Integer> unaryOperator = (n) -> n*n;
System.out.println("4 squared is- " + unaryOperator.apply(4));
System.out.println("7 squared is- " + unaryOperator.apply(7));
}
}
Output
4 squared is- 16 7 squared is- 49
That's all for this topic Pre-defined Functional Interfaces in Java. If you have any doubt or any suggestions to make please drop a comment. Thanks!
Related Topics
You may also like-
