- 使用 Spring Initializr 创建 Spring Boot 应用程序
- 在Spring Boot中配置Cassandra
- 在 Spring Boot 上配置 Tomcat 连接池
- 将Camel消息路由到嵌入WildFly的Artemis上
Lambda表达式是JDK 1.8中一个重要的新特性。
lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
Lambda 表达式(Lambda expression)可以看作是一个匿名函数,基于数学中的λ演算得名,也可称为闭包(Closure) 。
基本语法:(parameters)->expression 或 (parameters)->{statements;}
Lambda表达式由三部分组成:
// 1. 不需要参数,返回值为 2
() -> 2;
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x;
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y;
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y;
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s)->System.out.print(s);
**函数式接口定义:**一个接口有且只有一个抽象方法 。
注意:
定义方式:
@FunctionalInterface
interface NoParameterNoReturn {
void test(); // 只能有一个抽象方法
}
另一种方式:
@FunctionalInterface
interface NoParameterNoReturn {
void test(); // 只能有一个抽象方法
default void test2(){
System.out.println("111");
}
}
//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
public class Test {
public static void main2(String[] args) {
//无返回值无参数
NoParameterNoReturn parameterNoReturn = ()-> System.out.println("重写方法");
}
}
// 无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}
public class Test {
public static void main(String[] args) {
//无返回值有一个参数
OneParameterNoReturn oneParameterNoReturn = (a)->{System.out.println(a);};
oneParameterNoReturn.test(10);
OneParameterNoReturn oneParameterNoReturn1 = a-> System.out.println(a);
oneParameterNoReturn1.test(10);
OneParameterNoReturn oneParameterNoReturn2 = System.out::println;
oneParameterNoReturn2.test(10);
}
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
}
public class Test {
public static void main(String[] args) {
MoreParameterNoReturn moreParameterNoReturn = (a,b)->{
System.out.println(a+b);
};
moreParameterNoReturn.test(10,20);
MoreParameterNoReturn moreParameterNoReturn1 = (a, b) -> System.out.println(a+b);
moreParameterNoReturn1.test(20,30);
}
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
}
public class Test {
public static void main(String[] args) {
NoParameterReturn noParameterReturn = ()->{return 10;};
int ret = noParameterReturn.test();
System.out.println(ret);
NoParameterReturn noParameterReturn1 = ()->10;
int ret1 = noParameterReturn1.test();
System.out.println(ret1);
}
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
}
public class Test {
public static void main(String[] args) {
OneParameterReturn oneParameterReturn = (a) -> {return a+11;};
int ret = oneParameterReturn.test(10);
System.out.println(ret);
OneParameterReturn oneParameterReturn1 = a -> a+11;
System.out.println(oneParameterReturn1.test(10));
}
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
}
public class Test {
public static void main(String[] args) {
MoreParameterReturn moreParameterReturn = (a,b) -> {return a+b;};
moreParameterReturn.test(10,20);
MoreParameterReturn moreParameterReturn1 = (a,b) -> a+b;
System.out.println(moreParameterReturn1.test(30,40));
}
}
Lambda 表达式中存在变量捕获 ,了解了变量捕获之后,我们才能更好的理解Lambda 表达式的作用域 。Java当中的匿名类中,会存在变量捕获。
class Test1{
public void func(){
System.out.println("func");
}
}
public class TestDemo {
public static void main(String[] args) {
int a = 100;
new Test1(){
@Override
public void func() {
System.out.println("内部类,重写了func方法");
System.out.println("捕获变量, 要么是常量,要么未发生的变量" + a);
}
}.func();
}
}
在上述代码当中的变量a就是,捕获的变量。这个变量要么是被final修饰,如果不是被final修饰的 你要保证在使用之前,没有修改。
错误示例1:
错误示例2:
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
public static void main(String[] args) {
int a = 10;
NoParameterNoReturn noParameterNoReturn = ()->{
// a = 99; error
System.out.println("捕获变量:"+a);
};
noParameterNoReturn.test();
}
为了能够让Lambda和Java的集合类集更好的一起使用,集合当中,也新增了部分接口,以便与Lambda表达式对接。
对应的接口 | 新增的方法 |
---|---|
Collection | removeIf()``spliterator()``stream()``parallelStream()``forEach() |
List | replaceAll()``sort() |
Map | getOrDefault()``forEach()``replaceAll()``putIfAbsent()``remove()``replace()``computeIfAbsent()``computeIfPresent()``compute()``merge() |
forEach()
方法演示
使用示例:
class Test1{
public void func(){
System.out.println("func");
}
}
public class TestDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("ze");
list.add("www");
list.add("qwer");
list.add("lambda");
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
list.forEach(s-> System.out.println(s));
}
}
sort()
方法的演示
使用示例:
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("ze");
list.add("www");
list.add("qwer");
list.add("lambda");
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
System.out.println(list);
list.sort((o1, o2) -> o1.length()-o2.length());
System.out.println(list);
}
forEach()
方法
代码示例:
public static void main(String[] args) {
HashMap<Integer,String> map = new HashMap<>();
map.put(1,"ze");
map.put(2,"www");
map.put(3,"qwer");
map.put(4,"lambda");
map.forEach(new BiConsumer<Integer, String>() {
@Override
public void accept(Integer integer, String s) {
System.out.println("key:"+integer+"value:"+s);
}
});
map.forEach((key,value)-> System.out.println("key:"+key+"value:"+value));
}
Lambda表达式的优点很明显,在代码层次上来说,使代码变得非常的简洁。缺点也很明显,代码不易读。
可以使用 lambda 和函数创建有序对(Lisp 中的缺点),如 Use of lambda for cons/car/cdr definition in SICP 所示。 它也适用于 Python
我正在尝试从另一个调用一个 AWS lambda 并执行 lambda 链接。这样做的理由是 AWS 不提供来自同一个 S3 存储桶的多个触发器。 我创建了一个带有 s3 触发器的 lambda。第一
根据以下源代码,常规 lambda 似乎可以与扩展 lambda 互换。 fun main(args: Array) { val numbers = listOf(1, 2, 3) f
A Tutorial Introduction to the Lambda Calculus 本文介绍乘法函数 The multiplication of two numbers x and y ca
我想弄清楚如何为下面的表达式绘制语法树。首先,这究竟是如何表现的?看样子是以1和2为参数,如果n是 0,它只会返回 m . 另外,有人可以指出解析树的开始,还是一个例子?我一直找不到一个。 最佳答案
在 C++0x 中,我想知道 lambda 函数的类型是什么。具体来说: #include type1 foo(int x){ return [x](int y)->int{return x * y
我在其中一个职位发布中看到了这个问题,它询问什么是 lambda 函数以及它与高阶函数的关系。我已经知道如何使用 lambda 函数,但不太自信地解释它,所以我做了一点谷歌搜索,发现了这个:What
很难说出这里问的是什么。这个问题是含糊的、模糊的、不完整的、过于宽泛的或修辞性的,无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开它,visit the help center 。 已关
Evaluate (((lambda(x y) (lambda (x) (* x y))) 5 6) 10) in Scheme. 我不知道实际上该怎么做! ((lambda (x y) (+ x x
我正在处理 MyCustomType 的实例集合如下: fun runAll(vararg commands: MyCustomType){ commands.forEach { it.myM
Brian 在他对问题 "Are side effects a good thing?" 的论证中的前提很有趣: computers are von-Neumann machines that are
在 Common Lisp 中,如果我希望两个函数共享状态,我将按如下方式执行 let over lambda: (let ((state 1)) (defun inc-state () (in
Evaluate (((lambda(x y) (lambda (x) (* x y))) 5 6) 10) in Scheme. 我不知道实际上该怎么做! ((lambda (x y) (+ x x
作为lambda calculus wiki说: There are several possible ways to define the natural numbers in lambda cal
我有一个数据类,我需要初始化一些 List .我需要获取 JsonArray 的值(我使用的是 Gson)。 我做了这个函数: private fun arrayToList(data: JsonAr
((lambda () )) 的方案中是否有简写 例如,代替 ((lambda () (define x 1) (display x))) 我希望能够做类似的事情 (empty-lam
我在 Java library 中有以下方法: public void setColumnComparator(final int columnIndex, final Comparator colu
我正在研究一个函数来计算国际象棋游戏中棋子的有效移动。 white-pawn-move 函数有效。当我试图将其概括为任一玩家的棋子 (pawn-move) 时,我遇到了非法函数调用。我已经在 repl
考虑这段代码(在 GCC 和 MSVC 上编译): int main() { auto foo = [](auto p){ typedef decltype(p) p_t;
我正在阅读一个在 lambda 内部使用 lambda 的片段,然后我想通过创建一个虚拟函数来测试它,该函数从文件中读取然后返回最大和最小数字。 这是我想出来的 dummy = lambda path
我是一名优秀的程序员,十分优秀!