blocks|key|946267|text|这是两个不同的术语，在相同的背景下经常被提到。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|946268|lambda基本上只是一个匿名函数。例子：()+->+System.out.println("Hello").这是一个函数，但它没有名字。|unordered-list-item|offset|length|style|BOLD|CODE|946269|闭包是一个关于作用域的术语。例如，当引用lambda中的局部变量时，如下所示
int+localInt+=+17；saveThisFunction(()+->+System.out.println(localInt))；
创建一个闭包来捕获lambda中的localInt。从文本上看，显然访问lambda中的localInt应该是可以的，但请记住，可以在localInt从堆栈中弹出很长时间后存储和调用lambda。|946270|因此，创建lambda表达式通常需要创建闭包(隐式)。|946271|entityMap^0|0|0|6|L|X|0|0|2|3K|8|4B|8|4Y|8|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@$E|R|F|S|G|H]|$E|T|F|U|G|I]]|9|@]|A|$]]|$1|J|3|K|5|D|7|V|8|@$E|W|F|X|G|H]|$E|Y|F|Z|G|I]|$E|10|F|11|G|I]|$E|12|F|13|G|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|O|$]]

Those are two different terms that happen to often be mentioned in the same context.

<ul>
<li>A lambda is basically just an anonymous function. Example: <code>() -&gt; System.out.println("Hello")</code>. It's a function, but it doesn't have a name.</li>
<li>A closure is a term regarding scoping. When you for instance refer to a local variable inside a lambda, as follows

<pre><code>int localInt = 17;

saveThisFunction(() -&gt; System.out.println(localInt));
</code></pre>

you create a closure to capture <code>localInt</code> inside the lambda. Textually it looks obvious that it should be ok to access <code>localInt</code> inside the lambda, but keep in mind that the lambda can be stored and called long after the <code>localInt</code> has been popped from the stack.</li>
</ul>

So, creating a lambda expression often requires creating a closure (implicitly).

blocks|key|2243599|text|仅仅因为这些术语是等价的(我认为还有“匿名函数”)，这就是在不同语言中调用类似机制的方式，例如Groovy有闭包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2243600|顺便说一句，我觉得这样问是不对的|2243601|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

simply because the terms are equivalent (I think as well as "anonymous function") and this is how similar mechanism is being called in different languages, e.g. Groovy has closures

btw, I don't think this is right board to ask such questions

blocks|key|2243672|text|从技术上讲，lambda表达式和闭包是两个略有不同的东西，这是错误的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2243673|Lambdas是匿名函数，在Java中采用匿名的单一方法类的形式(参见功能接口)：|offset|length|style|BOLD|2243674|Runnable+r1+=+()+->+System.out.println("I'm+Runnable");|code-block|syntax|javascript|2243675|闭包是lambda表达式的一个特定的子类型，其中局部变量被绑定到在特定的封闭环境中定义的变量。|2243676|在Java世界中，您只是在从这里编写类似于这个示例的东西。|2243677|final+int+x+=+99;
++++++++
Consumer<Integer>+myConsumer+=+(y)+->+
{
++++System.out.println("x+=+"+%2B+x);
++++System.out.println("y+=+"+%2B+y);
};|2243678|对于更完整的闭包的抽象定义：|2243679|在操作上，闭包是存储函数和环境的数据结构:一个映射将函数的每个空闲变量(本地使用但在封闭作用域中定义的变量)与名称在创建闭包时绑定到的值或存储位置相关联。
闭包--不像普通函数--允许函数通过闭包对它们的引用访问这些捕获的变量，即使函数在其作用域之外被调用。|blockquote|2243680|来源|2243681|最后一部分意味着你可以这样做：|2243682|public+class+Funct{


++++public+static+Consumer<Integer>+getThatClosure(){
++++++++final+int+x+=+99;

++++++++Consumer<Integer>+myConsumer+=+(y)+->+
++++++++{
++++++++++++System.out.println("x+=+"+%2B+x);
++++++++++++System.out.println("y+=+"+%2B+y);
++++++++};
++++++++return+myConsumer;
++++}

++++public+static+void+main(String...+args){
++++++++Consumer<Integer>+cons=getThatClosure();
++++++++cons.accept(0);
++++}

}+|2243683|有了这个输出：|2243684|x=99
y=0|2243685|entityMap|0|LINK|mutability|MUTABLE|url|http://www.lambdafaq.org/what-is-a-functional-interface/|1|http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#accessing-local-variables|2|https://en.wikipedia.org/wiki/Closure_%2528computer_programming%2529^0|0|0|7|Z|4|0|0|0|0|2|0|E|2|1|0|0|0|1F|Q|26|1F|0|0|2|0|2|2|0|0|F|0|0|0|7|0|0^^$0|@$1|2|3|4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@$D|1N|E|1O|1|1P]]|A|$]]|$1|H|3|I|5|J|7|1Q|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1R|8|@$D|1S|E|1T|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1U|8|@]|9|@$D|1V|E|1W|1|1X]]|A|$]]|$1|Q|3|R|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|20|8|@$D|21|E|22|F|G]|$D|23|E|24|F|G]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|25|8|@$D|26|E|27|F|G]]|9|@$D|28|E|29|1|2A]]|A|$]]|$1|Z|3|10|5|6|7|2B|8|@$D|2C|E|2D|F|G]]|9|@]|A|$]]|$1|11|3|12|5|J|7|2E|8|@]|9|@]|A|$K|L]]|$1|13|3|14|5|6|7|2F|8|@$D|2G|E|2H|F|G]]|9|@]|A|$]]|$1|15|3|16|5|J|7|2I|8|@]|9|@]|A|$K|L]]|$1|17|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]]|18|$19|$5|1A|1B|1C|A|$1D|1E]]|1F|$5|1A|1B|1C|A|$1D|1G]]|1H|$5|1A|1B|1C|A|$1D|1I]]]]

Technically it's wrong, lambda expressions and closures are two slightly different things.
Lambdas are anonymous functions, that in the Java world take the form of anonymous single method classes (see also <a href="http://www.lambdafaq.org/what-is-a-functional-interface/" rel="nofollow noreferrer">functional interfaces</a>):
<pre><code>Runnable r1 = () -&gt; System.out.println(&quot;I'm Runnable&quot;);
</code></pre>
Closures are a specific sub-type of lambda expressions where local variables have been binded to variables defined in a specific enclosing environment.
In the Java world, you are just writing something similar to this example from <a href="http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#accessing-local-variables" rel="nofollow noreferrer">here</a>:
<pre><code>final int x = 99;
 
Consumer&lt;Integer&gt; myConsumer = (y) -&gt; 
{
 System.out.println(&quot;x = &quot; + x);
 System.out.println(&quot;y = &quot; + y);
};
</code></pre>
For a more complete abstract definition of closures:
<blockquote>
Operationally, a closure is a data structure storing a function together with an environment: a mapping associating each free variable of the function (variables that are used locally, but defined in an enclosing scope) with the value or storage location the name was bound to at the time the closure was created.
A closure—unlike a plain function—allows the function to access those captured variables through the closure's reference to them, even when the function is invoked outside their scope.
</blockquote>
<a href="https://en.wikipedia.org/wiki/Closure_%28computer_programming%29" rel="nofollow noreferrer">Source</a>
And that last part means that you can do this:
<pre><code>public class Funct{


 public static Consumer&lt;Integer&gt; getThatClosure(){
 final int x = 99;

 Consumer&lt;Integer&gt; myConsumer = (y) -&gt; 
 {
 System.out.println(&quot;x = &quot; + x);
 System.out.println(&quot;y = &quot; + y);
 };
 return myConsumer;
 }

 public static void main(String... args){
 Consumer&lt;Integer&gt; cons=getThatClosure();
 cons.accept(0);
 }

} 
</code></pre>
With this output:
<pre><code>x=99
y=0
</code></pre>

I am currently going through the Java Lambda and find it is also called Closures.

Please is there a reason why it is also called Closures? I want a technical explanation.

Why is Java Lambda also called Closures

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我目前正在浏览Java，并发现它也称为闭包。请问有什么理由叫闭包吗？我想要一个技术性的解释。

问为什么Java也称为闭包
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Java也称为闭包EN