目录

java的Lambda

文法：

举例：

详情链接：

groovy的closure

文法：

举例：

详情链接：

Kotlin的Lambda

文法：

举例：

 详情链接：

c++2.0的Lambda

文法：

举例：

详情链接：

java的Lambda

文法：

(arg1, arg2...) -> { body }

(type1 arg1, type2 arg2...) -> { body }

举例：

(int x, int y) -> { return x + y; }
(x, y) -> x + y
x -> x * x
() -> x
x -> { System.out.println(x); }

x -> String.valueOf(x)
x -> x.toString()
() -> x.toString()
() -> new ArrayList<>()

Comparator<String> c = (a, b) -> Integer.compare(a.length(), b.length());

详情链接：

https://blog.csdn.net/liao_hb/article/details/90081652#Lambdas

groovy的closure

文法：

{ [closureParameters -> ] statements }

举例：

{ item++ }                                //一个引用名为item的变量的闭包          
 
{ -> item++ }                              //通过添加箭头（ - >）可以明确地将闭包参数与代码分开         
 
{ println it }                             //使用隐式参数（it）的闭包    
 
{ it -> println it }                       //上面的一个替代版本，它是一个显式参数         
 
{ name -> println name }                   //在这种情况下，通常最好为参数使用显式名称        
 
{ String x, int y ->                       //一个闭包接受两个类型参数         
    println "hey ${x} the value is ${y}"
}
 
{ reader ->                                //闭包可以包含多个语句         
    def line = reader.readLine()
    line.trim()
}


def code = { 123 }
assert code() == 123

详情链接：

https://blog.csdn.net/liao_hb/article/details/88690400

Kotlin的Lambda

文法：

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

举例：

val product = items.fold(1) { acc, e -> acc * e }//拖尾 lambda 表达式
run { println("...") }//该 lambda 表达式是run函数调用时唯一的参数

//如果lambda 表达式只有一个参数,可以不用声明唯一的参数并忽略 ->,可以使用隐式参数it:
ints.filter { it > 0 } // 这个字面值是“(it: Int) -> Boolean”类型的

ints.filter {
    val shouldFilter = it > 0
    shouldFilter
}
//等价于
ints.filter {
    val shouldFilter = it > 0
    return@filter shouldFilter
}

//LINQ-风格的代码
strings.filter { it.length == 5 }.sortedBy { it }.map { it.toUpperCase() }

//如果 lambda 表达式的参数未使用，那么可以用下划线取代其名称：
map.forEach { _, value -> println("$value!") }

//如果 lambda 表达式具有 Pair 类型（或者 Map.Entry 或任何其他具有相应 componentN 函数的类型）
//的参数，那么可以通过将它们放在括号中来引入多个新参数来取代单个新参数：
//解构Map.Entry为(key, value)：
map.mapValues { entry -> "${entry.value}!" }
map.mapValues { (key, value) -> "$value!" }
map.mapValues { (_, value): Map.Entry<Int, String> -> "$value!" }
map.mapValues { (_, value: String) -> "$value!" }
{ a //-> …… } // 一个参数
{ a, b //-> …… } // 两个参数
{ (a, b) //-> …… } // 一个解构对
{ (a, b), c //-> …… } // 一个解构对以及其他参数

带有接收者的函数类型，例如 A.(B) -> C ，可以用特殊形式的函数字面值实例化—— 带有
接收者的函数字面值。这里有一个带有接收者的函数字面值及其类型的示例，其中在接收者对象上调用了 plus ：

val sum: Int.(Int) -> Int = { other -> plus(other) }

//匿名函数语法允许你直接指定函数字面值的接收者类型。 如果你需要使用带接收者的函数类
//型声明一个变量，并在之后使用它，这将非常有用。
val sum = fun Int.(other: Int): Int = this + other

当接收者类型可以从上下文推断时，lambda 表达式可以用作带接收者的函数字面值。

class HTML {
fun body() { …… }
}
fun html(init: HTML.() -> Unit): HTML {
val html = HTML() // 创建接收者对象
html.init() // 将该接收者对象传给该 lambda
return html
}
html { // 带接收者的 lambda 由此开始
body() // 调用该接收者对象的一个方法
}

 详情链接：

c++2.0的Lambda

文法：

捕获形式    说明
[]    不捕获任何外部变量
[i, …]    以值得形式捕获指定的多个外部变量（用逗号分隔）；如果引用捕获，需要显示声明&
[this]    以值的形式捕获this指针
[=]    以值的形式捕获所有外部变量
[&]    以引用形式捕获所有外部变量
[=, &x]    变量x以引用形式捕获，其余变量以传值形式捕获
[&, x]    变量x以值的形式捕获，其余变量以引用形式捕获

举例：

auto i = 5;
// [&] 表示外部变量都以引用的形式在lambda中使用，函数内部修改i的值会影响外部
// 这里的 -> auto 自动推导在c++11不支持，c++14中对auto进行了扩展
thread t1([&] () -> auto {
	i = 100;
	cout << "线程:" << i  << endl;
});
_sleep(10);
cout << i << endl;

详情链接：

https://blog.csdn.net/liao_hb/article/details/82221804#Lambda%C2%A0

请注明出处。

最后

以上就是谦让刺猬为你收集整理的java的Lambda、groovy的closure、Kotlin的Lambda和c++2.0的Lambdajava的Lambdagroovy的closureKotlin的Lambdac++2.0的Lambda的全部内容，希望文章能够帮你解决java的Lambda、groovy的closure、Kotlin的Lambda和c++2.0的Lambdajava的Lambdagroovy的closureKotlin的Lambdac++2.0的Lambda所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。