Lambda Expression vs. Anonymous Inner Class

1. Overview

Anonymous classes are like nested classes without a name. Lambda expressions were introduced in Java 8 to promote functional programming. And in some use cases, they’re used as a replacement for an anonymous class. In this article, we’ll explore the differences between an anonymous class and a lambda expression.

2. Anonymous Inner Class

An anonymous class implements interfaces and abstract classes without creating additional sub-classes. Further, an anonymous doesn’t have a name, and it provides a class definition and instantiates it at the same time.

Let’s now see an example of an anonymous class implementing the Runnable interface:

public class AnonymousClassExample{

    public static void main(String[] args){
        Thread t1 = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("Thread: "+Thread.currentThread().getName()+" started");
            }
        });
        t1.start();
    }
}

In the above example, we’ve created a class named AnonymousClassExample and provided Runnable interface implementation using an anonymous class. We’ve not created any separate class implementing the Runnable interface.

3. Lambda Expression

The lambda expression implements functional interfaces, which are those interfaces having a single unimplemented method. A Lambda expression is essentially a method definition without a name. It makes code more concise and readable. It also provides a way to pass a function as a method argument.

Now, let’s look at an example lambda expression implementing the Runnable interface:

public class LambdaExpressionExample{

    public static void main(String[] args){
        Thread t1 = new Thread(()->System.out.println("Thread: "+Thread.currentThread().getName()+" started"));
        t1.start();
    }
}

Here, we’re using an anonymous method. This will resolve to the run() method of the Runnable interface.

Even in the case of functional interfaces, we can use an anonymous class and lambda expression interchangeably. But there are differences between them. Now, let’s dive into those differences.

4. Anonymous Class vs. Lambda Expression

As mentioned earlier, the anonymous class is used for interfaces and abstract classes, whereas lambda expressions are used only for functional interfaces. Let’s check out some additional differences between them.

4.1. Syntax

An anonymous class provides a class definition and instantiates it at the same time. We use the new keyword and the name of the class or interface we’re implementing. It’s like calling the constructor, but we also provide method implementations and declare state variables. An anonymous class is an expression assigned to a reference variable of the class or interface it implements. Therefore, we also put a semicolon at the end.

On the other hand, a lambda expression is a method without a name. We provide the signature of the unimplemented method in the functional interface without a name. We also need not mention the data types of the method arguments. The method resolves at runtime.

4.2. Scope of this Keyword and Variables

In an anonymous class, this keyword refers to the anonymous class itself. But in the case of a lambda expression, this refers to its enclosing class.

We can also declare member variables in an anonymous class, which isn’t possible in the case of a lambda expression. Thus, an anonymous class can have a state. Variables declared inside the lambda expression act as local variables. Both of them, though, have access to member variables of the enclosing class.

4.3. Compilation

On compilation, for each anonymous class, a separate class file gets generated. The format of the class file is the class name followed by a dollar sign and a number. For instance, if we define an anonymous class in a class named TestClass, then after compilation, an additional file TestClass$1.class will be created.

On the other hand, in the case of a lambda expression, an invokedynamic instruction is added to the class file. This opcode instruction helps to figure out the functional interface method to be called.

When we compile the lambda expression, an equivalent private static or non-static method is added to the bytecode. The signature of this method matches the functional interface method.

In addition, captured arguments, if any lambda expression is used, are also prepended in the method argument list. Also, an additional indy call site is added. It has all the information required to invoke the private method generated for the lambda expression. During runtime, the call site is bootstrapped, and the linked private method is invoked.

4.4. Performance

Let’s now look at the high-level performance impact of both anonymous class and lambda expression. The lambda expression is better compared to the anonymous class in terms of performance. This is because an anonymous class leads to an extra class file on the compilation, which takes additional time during class loading and verification during runtime.

The performance of lambda expressions is better because the invokedynamic instruction lately binds the lambda expression to the functional interface method. Only the first call to a lambda expression is slow. Subsequent calls are faster.

5. Conclusion

In this article, we explored the differences between lambda expressions and anonymous inner classes. We learned how they differ in terms of syntax, compilation process, and performance.