Home
Search
Java Lambda ExpressionsInvoke lambda expressions, creating instances of Functions, Suppliers and Consumers.
Lambdas. In Java we use lambda syntax to create function objects. We can specify methods inside other methods—and even pass methods as arguments to other methods.
A lambda has a shape, one determined by its parameters and return values (if any) and their types. Classes like Function, Supplier, Consumer, accept lambdas with specific shapes.
Example expression. This program creates a Function object from a lambda expression. The lambda expression accepts one argument, an Integer, and returns another Integer.
Left side On the left of a lambda expression, we have the parameters. Two or more parameters can be surrounded by "(" and ")" chars.
Right side This is the return expression—it is evaluated using the parameters. It is executed and, when required, returned.
Apply In this program, we call apply() on the Function object. This executes and returns the expression—10 is changed to 20.
import java.util.function.*; public class Program { public static void main(String[] args) { // Create a Function from a lambda expression. // ... It returns the argument multiplied by two. Function<Integer, Integer> func = x -> x * 2; // Apply the function to an argument of 10. int result = func.apply(10); System.out.println(result); } }
20
Supplier, lambda arguments. A Supplier object receives no arguments. We use an empty argument list to specify a lambda expression with no arguments.
Tip A Supplier provides values. We call get() on it to retrieve its value—it may return different values when called more than once.
import java.util.function.*; public class Program { static void display(Supplier<Integer> arg) { System.out.println(arg.get()); } public static void main(String[] args) { // Pass lambdas to the display method. // ... These conform to the Supplier class. // ... Each returns an Integer. display(() -> 10); display(() -> 100); display(() -> (int) (Math.random() * 100)); } }
10 100 21
Predicate Lambda, ArrayList. The term predicate is used in computer science to mean a boolean-returning method. A Predicate object receives one value and returns true or false.
RemoveIf This method on ArrayList receives a Predicate. Here, we remove all elements starting with the letter "c."
ArrayList, String
import java.util.ArrayList; public class Program { public static void main(String[] args) { // Create ArrayList and add four String elements. ArrayList<String> list = new ArrayList<>(); list.add("cat"); list.add("dog"); list.add("cheetah"); list.add("deer"); // Remove elements that start with c. list.removeIf(element -> element.startsWith("c")); System.out.println(list.toString()); } }
[dog, deer]
Consumer. Opposite a Supplier, a Consumer acts upon a value but returns nothing. It means a void method. We can use a consumer to call println or other void methods.
Also A Consumer can be used to mutate data, as in an array, ArrayList or even just a class field.
import java.util.function.*; public class Program { static void display(int value) { switch (value) { case 1: System.out.println("There is 1 value"); return; default: System.out.println("There are " + Integer.toString(value) + " values"); return; } } public static void main(String[] args) { // This consumer calls a void method with the value. Consumer<Integer> consumer = x -> display(x - 1); // Use the consumer with three numbers. consumer.accept(1); consumer.accept(2); consumer.accept(3); } }
There are 0 values There is 1 value There are 2 values
UnaryOperator. This functional object receives a value of a certain type (like Integer) and returns a same-typed value. So it operates on, and returns, a value.
import java.util.function.*; public class Program { public static void main(String[] args) { // This returns one value of the same type as its one parameter. // ... It means the same as the Function below. UnaryOperator<Integer> operator = v -> v * 100; // This is a generalized form of UnaryOperator. Function<Integer, Integer> function = v -> v * 100; System.out.println(operator.apply(5)); System.out.println(function.apply(6)); } }
500 600
UnaryOperator, ArrayList. This example uses a lambda expression as a UnaryOperator argument to the ArrayList's replaceAll method. It adds 10 to all elements.
ArrayList add, insert
Note The forEach method on ArrayList does not change element values. ReplaceAll allows this action.
import java.util.ArrayList; public class Program { public static void main(String[] args) { // Add ten to each element in the ArrayList. ArrayList<Integer> list = new ArrayList<>(); list.add(5); list.add(6); list.add(7); list.replaceAll(element -> element + 10); // ... Display the results. System.out.println(list); } }
[15, 16, 17]
BiConsumer, HashMap. A BiConsumer is a functional object that receives two parameters. Here we use a BiConsumer in the forEach method on HashMap.
HashMap
Note The forEach lambda here, which is a valid BiConsumer, prints out all keys, values, and the keys lengths.
import java.util.HashMap; public class Program { public static void main(String[] args) { HashMap<String, String> hash = new HashMap<>(); hash.put("cat", "orange"); hash.put("dog", "black"); hash.put("snake", "green"); // Use lambda expression that matches BiConsumer to display HashMap. hash.forEach((string1, string2) -> System.out.println(string1 + "..." + string2 + ", " + string1.length())); } }
cat...orange, 3 snake...green, 5 dog...black, 3
Identifiers. These do not matter in a lambda expression. The identifiers do not impact external parts of the program, but can be accessed on both sides of the lambda.
Note As with variables, there is no reason to name the lambda expression variable a specific thing. Here we use the word "carrot."
import java.util.function.Consumer; public class Program { public static void main(String[] args) { // The identifier in the lambda expression can be anything. Consumer<Integer> consumer = carrot -> System.out.println(carrot); consumer.accept(1989); } }
1989
Benchmark, apply. Here we benchmark a Function object, which we invoke with apply(), against a static method. Both code blocks do the same thing.
Version 1 This version of the code uses a lambda expression and calls the apply() method to execute it many times.
Version 2 Here we invoke a method directly, using traditional Java syntax. This version is much faster.
Result If a method can be called with no loss of code clarity, this may result in better performance over a lambda or functional object.
Methods
import java.util.function.*; public class Program { static int method(int element) { return element + 1; } public static void main(String[] args) { Function<Integer, Integer> function = element -> element + 1; long t1 = System.currentTimeMillis(); // Version 1: apply a function specified as a lambda expression. for (int i = 0; i < 10000000; i++) { int result = function.apply(i); if (result == -1) { System.out.println(false); } } long t2 = System.currentTimeMillis(); // Version 2: call a static method. for (int i = 0; i < 10000000; i++) { int result = method(i); if (result == -1) { System.out.println(false); } } long t3 = System.currentTimeMillis(); // ... Benchmark results. System.out.println(t2 - t1); System.out.println(t3 - t2); } }
93 ms, Function apply() 6 ms, method call
Filter. This method works on streams like IntStream. It returns a modified stream. And we can use methods like findFirst to access elements from filtered streams.
Filter
Sum. With a lambda expression, IntStream and the reduce() method we can sum an array. This approach has better parallel potential. But it is slow in simple cases.
Sum
A review. At first, functional object names in Java are confusing. With practice, and some effort, the functional object system in this language is powerful and expressive.
Home
© 2007-2022 sam allen.
see site info on the changelog.