Java Lambda expressions

“This is the fifth day of my participation in the Gwen Challenge in November. Check out the details: The Last Gwen Challenge in 2021.”

Java lambda expressions are new in Java 8. Java lambda expressions are Java’s first step into functional programming. Thus, a Java lambda expression is a function that can be created without belonging to any class. Java lambda expressions can be passed like objects and executed as needed.

Java lambda expressions are often used to implement simple event listeners/callbacks, or for functional programming using the [Java Streams API]. Java Lambda expressions are also often used for [functional programming in Java]

Java Lambdas and the single-method interface

Functional programming is often used to implement event listeners. Event listeners in Java are typically defined as Java interfaces that use a single method. Here is an example of a fictitious single-method interface:

public interface StateChangeListener {

    public void onStateChange(State oldState, State newState);

}
Copy the code

This Java interface defines a method that is invoked whenever there is a state change (no matter what is observed).

In Java 7, you must implement this interface to listen for state changes. Imagine that you have a class called StateOwner that registers State Event listeners. Here’s an example:

public class StateOwner { public void addStateListener(StateChangeListener listener) { ... }}Copy the code

In Java 7, you can add event listeners using an anonymous interface implementation, as follows:

StateOwner stateOwner = new StateOwner();

stateOwner.addStateListener(new StateChangeListener() {

    public void onStateChange(State oldState, State newState) {
        // do something with the old and new state.
    }
});
Copy the code

Start by creating a StateOwner instance. The anonymous implementation of the StateChangeListener interface is then added as a listener on the StateOwner instance.

In Java 8, you can add event listeners using Java lambda expressions, as follows:

StateOwner stateOwner = new StateOwner();

stateOwner.addStateListener(
    (oldState, newState) -> System.out.println("State changed")
);
Copy the code

Lambda expressions are this part:

(oldState, newState) -> System.out.println("State changed")
Copy the code

The lambda expression matches the parameter type of the addStateListener() method parameter. If the lambda expression matches the type of the argument (in this case, the StateChangeListener interface), the lambda expression is converted to a function that implements the same interface as the argument.

Java lambda expressions can only be used if the matching type is a single method interface. In the above example, a lambda expression is used as a parameter, where the parameter type is the StateChangeListener interface. This interface has only one method. Therefore, the lambda expression successfully matches the interface.

Match Lambdas to interfaces

Individual method interfaces are sometimes called functional interfaces. Matching Java lambda expressions with function interfaces is divided into the following steps:

• Does the interface have only one abstract (unimplemented) method?
• Do lambda expression arguments match those of a single method?
• Does the return type of a lambda expression match the return type of a single method?

If the answer to these three questions is yes, then the given lambda expression will successfully match the interface.

import java.io.IOException; import java.io.OutputStream; public interface MyInterface { void printIt(String text); default public void printUtf8To(String text, OutputStream outputStream){ try { outputStream.write(text.getBytes("UTF-8")); } catch (IOException e) { throw new RuntimeException("Error writing String as UTF-8 to OutputStream", e); } } static void printItToSystemOut(String text){ System.out.println(text); }}Copy the code

MyInterface myInterface = (String text) -> {
    System.out.print(text);
};
Copy the code

Lambda expressions with anonymous interface implementations

Although lambda expressions are close to anonymous interface implementations, there are some differences worth noting.

The main difference is that anonymous interface implementations can have stateful (member variables), whereas lambda expressions cannot. Take a look at this screen:

public interface MyEventConsumer {

    public void consume(Object event);

}
Copy the code

This interface can be implemented using an anonymous interface implementation, as follows:

MyEventConsumer consumer = new MyEventConsumer() { public void consume(Object event){ System.out.println(event.toString() + " consumed"); }};Copy the code

The anonymous MyEventConsumer implementation can have its own internal state. Check out this redesign:

MyEventConsumer myEventConsumer = new MyEventConsumer() {
    private int eventCount = 0;
    public void consume(Object event) {
        System.out.println(event.toString() + " consumed " + this.eventCount++ + " times.");
    }
};
Copy the code

Notice how the anonymous MyEventConsumer implementation now has a field called eventCount.

Lambda expressions cannot have such fields. Thus, lambda expressions are said to be stateless.

stateOwner.addStateListener(new StateChangeListener() {

    public void onStateChange(State oldState, State newState) {
        // do something with the old and new state.
    }
});
Copy the code

stateOwner.addStateListener(
    (oldState, newState) -> System.out.println("State changed")
);
Copy the code

Lambda parameter

Since Java lambda expressions are really methods, lambda expressions can take arguments just like methods. The (oldState, newState) section of the lambda expression shown earlier specifies the arguments to the lambda expression. These parameters must match the method’s parameters on a single method interface. In this case, these parameters must be with StateChangeListener interface theonStateChangeonStateChange () method of parameter matching:

public void onStateChange(State oldState, State newState);
Copy the code

The number of arguments in a lambda expression and method must at least match.

Second, if you specify any parameter types in a lambda expression, those types must also match. I haven’t shown you how to place types on lambda expression parameters (shown later in this article), but in many cases, you don’t need them.

() -> System.out.println("Zero parameter lambda");
Copy the code

A parameter

If you take a method that matches a Java lambda expression with an argument by taking one argument, you can write a lambda expression like this:

(param) -> System.out.println("One parameter: " + param);
Copy the code

Note that the parameters are listed in parentheses.

You can also omit the parentheses when a lambda expression takes a single argument, as follows:

param -> System.out.println("One parameter: " + param);
Copy the code

(p1, p2) -> System.out.println("Multiple parameters: " + p1 + ", " + p2);
Copy the code

The parameter types

If the compiler cannot infer the parameter type from the lambda matching function interface method, it may sometimes be necessary to specify the parameter type for the lambda expression. Don’t worry, the compiler will tell you when it happens. Here are examples of Java Lambda parameter types:

(Car car) -> System.out.println("The car is: " + car.getName());
Copy the code

As you can see, the type of the CAR parameter (CAR) is written in front of the parameter name itself, just as you would declare the parameter in a method elsewhere or implement the interface anonymously.

Function<String, String> toLowerCase = (var input) -> input.toLowerCase();
Copy the code

The Lambda function body

The body of a lambda expression, and therefore the body of the function/method it represents, is specified to the -> right of the lambda declaration:

 (oldState, newState) -> System.out.println("State changed") 
Copy the code

If your lambda expression needs to consist of multiple lines, you can include the body of the lambda function in {} parentheses, which Java also needs when declaring methods elsewhere. Here’s an example:

 (oldState, newState) -> {
    System.out.println("Old state: " + oldState);
    System.out.println("New state: " + newState);
  }
Copy the code

(param) -> {
    System.out.println("param: " + param);
    return "return value";
  }
Copy the code

(a1, a2) -> { return a1 > a2; }
Copy the code

(a1, A2) -> A1 > A2;Copy the code

Lambdas as objects

A Java lambda expression is essentially an object. You can assign a lambda expression to a variable and pass it around like any other object. Here’s an example:

public interface MyComparator {

    public boolean compare(int a1, int a2);

}
Copy the code

MyComparator myComparator = (a1, a2) -> a1 > a2;

boolean result = myComparator.compare(2, 5);
Copy the code

The first code block shows the interface implemented by the lambda expression. The second code block shows the definition of a lambda expression, how it is assigned to a variable, and finally how it is invoked by calling the interface methods implemented by the lambda expression.

Local variable capture

Java lambda can capture the value of a local variable declared outside the body of a lambda. To illustrate this, first look at the single method interface:

public interface MyFactory {
    public String create(char[] chars);
}
Copy the code

Now, look at this lambda expression that implements the MyFactory interface:

MyFactory myFactory = (chars) -> {
    return new String(chars);
};
Copy the code

Currently, this lambda expression refers only to the argument values (chars) passed to it. But we can change that. Here is an updated version of the String variable that references the external declaration of the lambda function:

String myString = "Test";

MyFactory myFactory = (chars) -> {
    return myString + ":" + new String(chars);
};
Copy the code

As you can see, the lambda body now refers to the local variable myString declared outside the lambda body. This is only possible if the variable is “validly final”, and only if the variable is “validly final”, meaning that it does not change its value after allocation. If the value of the myString variable subsequently changes, the compiler complains about references to it within the lambda body.

public class EventConsumerImpl {private String name = "MyConsumer"; Public void Attach (MyEventProducer eventProducer){eventProducer. Listen (e -> {system.out.println (this.name); }); }}Copy the code

Static variable capture

Java lambda expressions can also capture static variables. This is not surprising, since static variables can be accessed anywhere in a Java application, provided that static variables are accessible (packaged scoped or public).

Here is an example class that creates a lambda that refers to a static variable within the body of the lambda:

public class EventConsumerImpl { private static String someStaticVar = "Some text"; public void attach(MyEventProducer eventProducer){ eventProducer.listen(e -> { System.out.println(someStaticVar); }); }}Copy the code

The value of a static variable is also allowed to change after a lambda capture.

Again, the above class design is a bit ridiculous. Don’t overthink it. This class is mainly used to show you that a lambda can access static variables.

public interface MyPrinter{
    public void print(String s);
}
Copy the code

MyPrinter myPrinter = (s) -> { System.out.println(s); };
Copy the code

MyPrinter myPrinter = s -> System.out.println(s);
Copy the code

MyPrinter myPrinter = System.out::println;
Copy the code

Static method reference

The easiest method to refer to is the static method. Here is the first example of a single function interface:

public interface Finder {
    public int find(String s1, String s2);
}
Copy the code

This is a static method and we want to create a method reference:

public class MyClass{ public static int doFind(String s1, String s2){ return s1.lastIndexOf(s2); }}Copy the code

Finally, here is a Java lambda expression that references a static method:

Finder finder = MyClass::doFind;
Copy the code

Because the arguments to finder.find () and the myClass.dofind () methods match, you can create a lambda expression that implements Finder.find() and references the myClass.dofind () method.

public interface Finder {
    public int find(String s1, String s2);
}
Copy the code

Finder finder = String::indexOf;
Copy the code

Finder finder = (s1, s2) -> s1.indexOf(s2);
Copy the code

Example method reference

Third, instance methods can also be referenced from a lambda definition. First, let’s look at a single method interface definition:

public interface Deserializer {
    public int deserialize(String v1);
}
Copy the code

This interface represents a component that can “deserialize” String to int.

Now look at this StringConverter class:

public class StringConverter { public int convertToInt(String v1){ return Integer.valueOf(v1); }}Copy the code

The ‘convertToInt()’ method has the same signature as the ‘deserializer’ and ‘deserialize()’ method’s ‘deserialize()’ method. So we can create an instance of ‘stringConverter’ and reference its’ convertToInt() ‘method from a Java lambda expression, as follows:

StringConverter stringConverter = new StringConverter(); Deserializer des = stringConverter::convertToInt;Copy the code

The lambda expression created on the second line of the two lines references the convertToInt method of the StringConverter instance created on the first line.

MyClass::new
Copy the code

public interface Factory {
    public String create(char[] val);
}
Copy the code

Factory factory = String::new;
Copy the code

Factory factory = chars -> new String(chars);
Copy the code