Background
In series of previous posts on Java 8 features we saw Lambda expressions and how to used them.
We saw basis of a Lambda expression is a functional interface. And then we saw a few functional interfaces as part of introduction to method references -
In this post well see some common functional interfaces that Java provides that you can use at your disposal.
Common Functional interfaces
A new package is introduced since Java 8 that holds all such common functional interfaces. This package is
- java.util.function
For now lets go over some commonly used functional interfaces from this package.
NOTE : The convention used here is generic type T for type parameter, for second type parameter the next letter U and for a distinct return type R is used as the generic type.
Predicate : Takes a single paramter of any type and returns a boolean [boolean test(T t)]
Predicate functional interface looks like -
1 2 3 4 5 6 7 8 9 10 11 12 | @FunctionalInterface public interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the input argument matches the predicate, * otherwise {@code false} */ boolean test(T t); //other methods } |
It accepts a parameter of type T and returns a boolean.
Note I have skipped other methods in the interface like default and static methods (Remember default methods and static methods do not affect the functional status of an interface)
Eg.
Output :
true
false
Note I have skipped other methods in the interface like default and static methods (Remember default methods and static methods do not affect the functional status of an interface)
Eg.
1 2 3 | Predicate<String> emptyPredicate = x -> x.isEmpty(); System.out.println(emptyPredicate.test( "" )); System.out.println(emptyPredicate.test( "abc" )); |
Output :
true
false
Consumer : Takes a single paramter of any type and has a void return type [void accept(T t)]
Consumer looks like below -
1 2 3 4 5 6 7 8 9 | @FunctionalInterface public interface Consumer<T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t); } |
It accepts an input parameter of type T and does does not return anything (has a void return type). It consumes the input.
Eg.
1 2 | Consumer<String> printFunc = x -> System.out.println(x); printFunc.accept( "Hello World!" ); |
Output :
Hello World!
Supplier : Does not take any parameter and returns any type [ T get()]
Supplier looks like -
1 2 3 4 5 6 7 8 9 10 | @FunctionalInterface public interface Supplier<T> { /** * Gets a result. * * @return a result */ T get(); } |
Eg.
1 2 | Supplier<String> strSupplier = () -> "SOME_CONSTANT" ; System.out.println(strSupplier.get()); |
Output :
SOME_CONSTANT
I know that a lame example :) You can simple define and use a constant. Have used this to help you understand how it works. All constructor references in method references are essentially variants of supplier.
I know that a lame example :) You can simple define and use a constant. Have used this to help you understand how it works. All constructor references in method references are essentially variants of supplier.
UnaryOperator : Takes a single paramter of any type and returns of same type. [R apply(T t)]
UnaryOperator actually extends Function functional interface. Function looks like below -
1 2 3 4 5 6 7 8 9 | public interface Function<T, R> { /** * Applies this function to the given argument. * * @param t the function argument * @return the function result */ R apply(T t); } |
So as you see it take input parameter of type T and returns a parameter of type R. UnaryOperator is a special kind of Function where T and R are same. So it take input and returns output of same type.
Eg.
1 2 | UnaryOperator<String> prefixOp = (name) -> "Mr. " + name; System.out.println(prefixOp.apply( "Aniket" )); |
Output :
Mr. Aniket
That's some common functional interface. Now there are "Bi" versions of above interfaces that take in 2 inputs. For eg.
- BiConsumer<T, U> : Similar to Consumer<T> but takes two inputs of type T and consumes them i.e void return type.
- BiPredicate<T, U> : Similar to Predicate<T> but takes 2 inputs of type T and U and returns a boolean.
- BiFunction<T, U, R> : Similar to Function<T, R> but takes 2 inputs of type T and U and returns a parameter of type R.
- BinaryOperator<T> : Similar to UnaryOperator<T> but takes 2 parameters of type T and returns parameter of type T.
Summary
Related Links
- Using Lambda Expressions from Java 8(OSFG)
- Using Lambda expressions from Java 8 - Part 2(OSFG)
- Java 8 Method references and Lambda expression
- https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
- Whats new in Java 8?(OSFG)
No comments:
Post a Comment