Lambda表达式
lambda是一种匿名函数:
正常的函数 :
返回值 方法名 (参数列表){
方法体;
}
lambda表达式
(参数列表)->方法体;
函数式接口
要了解Lambda表达式,首先需要了解什么是函数式接口;函数式接口定义:一个接口有且只有一个抽象方法.
1.如果一个接口只有一个抽象方法，那么该接口就是一个函数是接口 2.如果我们在某个接口上声明@FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。
@FunctionalInterface
interface NoParameterNoReturn{
void test();
// void test1();
// void test2();//只能有一个方法,当有多个方法就会报错
}
lambda表达式的基本使用
使代码变简洁，但是可读性变差。
无参数无返回值
@FunctionalInterface
interface NoParameterNoReturn{
void test();
}
public static void main(String[] args) {
NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
@Override
public void test() {
System.out.println("哈哈");
}
};
noParameterNoReturn.test();
System.out.println("=================================");
//使用lambda表达式
NoParameterNoReturn noParameterNoReturn1 = ()->
System.out.println("haha");
noParameterNoReturn1.test();
}
运行结果：
一个参数无返回值
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}
public static void main(String[] args) {
//OneParameterNoReturn oneParameterNoReturn = (int a) -> System.out.println(a);
OneParameterNoReturn oneParameterNoReturn = a -> System.out.println(a);
oneParameterNoReturn.test(10);
}
运行结果：
多个参数无返回值
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
}
public static void main(String[] args) {
MoreParameterNoReturn moreParameterNoReturn =
(int a,int b)-> System.out.println(a+b);
// MoreParameterNoReturn moreParameterNoReturn =
// (a,b)-> System.out.println(a+b);//类型可以省略，但是一般不建议省略类型
moreParameterNoReturn.test(10,20);
}
运行结果：
无参数有返回值
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
}
public static void main(String[] args) {
// NoParameterReturn noParameterReturn = ()-> {return 10;};
NoParameterReturn noParameterReturn = ()-> 10;
System.out.println(noParameterReturn.test());
}
运行结果：
一个参数有返回值
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
}
public static void main(String[] args) {
// OneParameterReturn oneParameterReturn = (int a)-> a;
OneParameterReturn oneParameterReturn = a-> a;
System.out.println(oneParameterReturn.test(19));
}
运行结果：
多个参数有返回值
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
}
public static void main(String[] args) {
// MoreParameterReturn moreParameterReturn = (int a,int b) -> a + b;
MoreParameterReturn moreParameterReturn = (a,b) -> a + b;
System.out.println(moreParameterReturn.test(10, 20));
}
运行结果：
变量捕获
匿名内部类的变量捕获
class Test{
public void func(){
System.out.println("func()");
}
public static void main(String[] args) {
int a = 10;
new Test(){
@Override
public void func(){
//a = 99;若改变a的值就会报错
System.out.println("这是一个重写的内部类方法");
System.out.println("我是一个常量或者是一个没有改变过值的变量" + a);//这里a就是一个被捕获的变量
}
}.func();
}
上述代码中a就是被捕获的变量，这个变量要么是个常量（被final修饰），要么就是没有被改变的量，若a的值被修稿就会编译报错。
lambda中的变量捕获
在lambda表达式中也可以进行变量捕获，效果与匿名内部类一样。
@FunctionalInterface
interface NoParameterNoReturn{
void test();
}
public static void main(String[] args) {
int a = 10;
//使用lambda表达式
NoParameterNoReturn noParameterNoReturn1 = ()->{
//a = 99;编译报错
System.out.println("捕获变量：" + a);
}；
noParameterNoReturn1.test();
}
Lambda在集合中的使用
foreach方法
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Hello");
list.add("world");
list.add("hello");
list.add("lambda");
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("===========================");
list.forEach(s -> System.out.println(s));
}
运行结果：
sort方法
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Hello");
list.add("world");
list.add("hello");
list.add("lambda");
System.out.println(list);
// list.sort(new Comparator<String>() {
// @Override
// public int compare(String o1, String o2) {
// return o1.compareTo(o2);
// }
// });
// System.out.println(list);
System.out.println("===========================");
list.sort((o1,o2) -> {
return o1.compareTo(o2);
});
System.out.println(list);
}
运行结果：
优点：
1.代码简洁；
2.方便函数式编程
3.非常容易进行并行操作（？）
4.改善了集合的操作
缺点;
1.代码可读性变差
2.在非并行计算中，很多计算未必有传统的for性能要高
3.不容易进行调试