The difference and connection between Java closures and lambda expressions

Both closures and lambda expressions can capture local variables in Java: closures can capture free variables, while lambda expressions can only capture final or effectively final variables. A closure's free variables are accessible throughout its lifetime, whereas a lambda expression's captured variables are only accessible within the Lambda. A closure's free variables are stored on the heap, while a lambda expression's captured variables are stored on the stack. Lambda expressions create closures, and closures can contain Lambda expressions.

The difference and connection between closures and Lambda expressions in Java

Preface

Closures and Lambda expressions are both very useful techniques in Java programming. Both of them can capture local variables and store them outside the scope. However, there are some key differences between them.

Closures

A closure is a feature that captures variables declared in the environment in which it is executed, even after leaving that environment. These captured variables are called the "free variables" of the closure.

Lambda expression

Lambda expression is a simplified anonymous function. They can accept parameters and return a value. A lambda expression can also capture variables declared in its execution environment, but only if those variables are final(final) or effectively final(effectively final).

Differences

Although closures and Lambda expressions can both capture local variables, there are some key differences between them:

• Free variables: Closures can capture free variables, while Lambda expressions can only capture final or effectively final variables.
• Scope: Free variables of a closure can be accessed throughout their lifetime, even after leaving the scope in which they are defined. In contrast, a lambda expression's capture variables can only be accessed within the lambda expression.
• Memory management: Free variables of closures are stored in the heap, while captured variables of lambda expressions are stored in the stack.

Connection

Despite these differences, closures and lambda expressions are closely related:

• Lambda expressions can create closures: When a Lambda expression captures a free variable, it creates a closure.
• Closures can contain Lambda expressions: Closures can store Lambda expressions as free variables.

Practical case

Closure case:

class OuterClass {
    private int x = 10;

    public void printX() {
        Runnable runnable = () -> System.out.println(x);  // 闭包捕获自由变量 x
        runnable.run();
    }
}

Lambda expression case:

class OuterClass {
    private final int x = 10;

    public void printX() {
        System.out.println(x);  // Lambda 表达式可以使用 final 变量
    }
}

Conclusion

Closures and Lambda expressions are both useful techniques in Java. Understanding the differences and connections between them is important to writing efficient, maintainable code.

The above is the detailed content of The difference and connection between Java closures and lambda expressions. For more information, please follow other related articles on the PHP Chinese website!