lambda表达式
1 -用以往的方式对接口进行实现
1.1 -创建一个实现类进行实现
接口定义：
public interface Sum {
int add(int a,int b);
}实现类：
public class SumImpl implements Sum {
@Override
public int add(int a, int b) {
return a+b;
}
}测试：
public class Test1 {
public static void main(String[] args) {
Sum s = new SumImpl();
System.out.println(s.add(10,20 ));
//30
}
}1.2 -用匿名内部类的方式进行实现
接口定义：
public interface Sum {
int add(int a,int b);
}通过匿名内部类进行的实现：
// new 接口
Sum s = new Sum() {
// 方法重写，重写的就是接口中的方法
// java 方法中再定义方法的操作？？？ 不能方法套方法
// 方法可以书写的位置：======》方法只能写再类中
// ========》方法存在于类中
// 类没有名字======》匿名类
// 类存在于另一个类中=====》内部类
// ===============》匿名内部类
// java类 运行时 编译成 class文件
// Test1$1.class 匿名内部类命名规则：内部类所在的外部类的名字$数字
@Override
public int add(int a, int b) {
return a+b;
}
};
System.out.println(s.add(100, 300));特点：
1 匿名内部类进行实现，测试类中，代码书写比较繁琐
2 只要有一个类，再运行时被编译，例如：测试类中5个内部类
（执行时 编译的文件比较多，执行效率相对比较低）
2 -lambda表达式
2.1 -概念
lambda表达式是JAVA8中提供的一种新的特性，它支持JAVA也能进行简单的“函数式编程”。
它是一个匿名函数。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，它在实现接口的时候不会生成class文件，大大提升了编译时的效率。
2.2 -语法
要实现接口中的方法的形参 指向 实现接口中的方法，方法的逻辑 方法体
（） -> {}
使用lambda表达式前提条件
只能实现接口，并且接口中有且只有一个抽象方法
（1）接口定义(有参有返回值的方法)
public interface Sum {
int add(int a,int b);
}方法的实现：
Sum s = (int a,int b)->{return a+b;};
System.out.println(s.add(100,20 ));（2）接口定义（有参无返回值的方法）
public interface Sum {
void add(int a);
}方法的实现
Sum s = (int a)->{
System.out.println(a);
};
s.add(1000 );(3)接口定义(无参有返回值的方法)
public interface Sum {
int add();
}方法的实现
Sum a = ()->{return 10;};
System.out.println(a.add());(4)接口定义(无参有返回值的方法)
public interface Sum {
void add();
}方法的实现
Sum a = ()->{
System.out.println("没有传入数据");
};
a.add();2.3 -lambda表达式简化方式
简化方式，从参数入手进行简化：
lambda表达式实现的接口中的方法，方法是否有参数
1 如果方法没有参数，不用简化
2 如果方法有参数，如果方法有一个参数，参数的数据类型可以省略，并且同时（）可以省略
3 如果方法有参数，如果方法有多个参数，参数的数据类型可以省略
注意：数据类型要么全部省略 要么都不省略 （）不可以省略的
简化方式，从方法体入手进行简化
lambda表达式实现的接口中的方法，方法是否有返回值
1 方法无返回值的情况：
并且方法中只有一句逻辑代码，{}可以直接省略（注意：多行逻辑代码不可以省略）
2 方法有返回值的情况：
并且方法中只有一句逻辑代码，return关键词可以省略并且同时{}省略
(1) 接口定义(有参有返回值的方法)
public interface Sum {
int add(int a,int b);
}方法的实现
Sum s = (int a,int b)->{return a+b;};
System.out.println(s.add(100,20 ));方法的简化
Sum s = ( a, b)-> a+b;
System.out.println(s.add(100,20 ));（2）接口定义（有参无返回值的方法）
public interface Sum {
void add(int a);
}方法的实现
Sum s = (int a)->{
System.out.println(a);
};
s.add(1000 );方法的简化
Sum s = a->System.out.println(a);
s.add(1000 );（3） 接口定义（无参有返回值的方法）
public interface Sum {
int add();
}方法的实现
Sum a = ()->{return 10;};
System.out.println(a.add());方法的简化
Sum a = ()-> 10
System.out.println(a.add());（4） 接口定义（无参无返回值的方法）
public interface Sum {
void add();
}方法的实现
Sum a = ()->{
System.out.println("没有传入数据");
};
a.add();方法的简化
Sum a = ()->System.out.println("没有传入数据");
a.add();2.3 -lambda表达式中进行的方法引用
用以上lambda表达式对接口进行重写:
接口的定义
public interface Sum {
int add(Integer a,Integer b);
}通过lambda表达式进行接口中方法的实现
Sum s = ( a, b)->{
if(a==null){
a=0;
}
if (b==null){
b=0;
}
return a+b;
};
System.out.println(s.add(100,100 ));
Sum s1 = (a,b)->{
if(a==null){
a=0;
}
if (b==null){
b=0;
}
return a+b;
};
System.out.println(s1.add(100,20 ));
Sum s2 = (a,b)->{
if(a==null){
a=0;
}
if (b==null){
b=0;
}
return a+b;
};
System.out.println(s2.add(100,20 ));
}每实现一次接口，两个数相加的逻辑，就要写一次
java 相同逻辑的代码重复出现，========》代码冗余
对于重复逻辑的代码，我们应该一次定义，多次使用======》方法定义（方法封装）
(1)定义一个方法：静态方法
方法定义的要求：需要和接口中方法的参数个数，类型，顺序保持一致
需要和接口中方法的返回值，类型保持一致
public class AddUtil {
public static int sum(Integer a,Integer b){
if(a==null){
a=0;
}
if (b==null){
b=0;
}
return a+b;
}
}使用进行方法进行lambda表达式逻辑实现
Sum s = (Integer a,Integer b)->{ return AddUtil.sum(a,b);};
System.out.println(s.add(100,20 ));
Sum s = (a,b)-> AddUtil.sum(a,b);
System.out.println(s.add(100,20 ));所以我们引入lambda表达式对方法进行引用
规则：
方法所在的类名::静态方法的名称
Sum s = AddUtil::sum;
System.out.println(s.add(100,20 ));
Sum s1 = Integer::sum;
System.out.println(s1.add(10,20 ));(2)实例方法引用的书写
接口定义
public interface UpperInter {
String upper(String str);
}逻辑书写，实例方法中进行定义
public class UpperUtil {
public String test(String str){
String res = "";
char[] chars = str.toCharArray();
for(char c:chars){
// a 97 A 65
char r = (char)(c-32);
res+=r;
}
return res;
}
}lambda表达式中如何进行实例方法引用
UpperInter u = (String str)->{return new UpperUtil().test(str);};
System.out.println(u.upper("abc"));
UpperInter u = (str)-> new UpperUtil().test(str);;
System.out.println(u.upper("abc")); 实例方法引用：
书写规则：
new 构造方法::实例方法方法名
UpperInter u = new UpperUtil()::test;;
System.out.println(u.upper("abc"));(3)构造方法进行引用
类的定义
public class Cat {
private String name;
private Integer age;
private String type;
public Cat() {
}
public Cat(String name, Integer age, String type) {
this.name = name;
this.age = age;
this.type = type;
}
}接口功能，创建对象
public interface CreateCat {
Cat gen();
}
构造方法引用
书写规则：
类名::new
/* CreateCat c = ()->{return new Cat();};
System.out.println(c.gen());*/
/*CreateCat c = ()-> new Cat();
System.out.println(c.gen());*/
CreateCat c = Cat::new;
System.out.println(c.gen());
有参方法使用
CreateCat c = Cat::new;
System.out.println(c.gen("tomcat",3,"加菲猫"));(4)数组进行方法引用
public interface CreateArray {
int[] cre(int length);
}数组引用：
数组引用：
/* CreateArray c = (int length)->{return new int[length];};
System.out.println(c.cre(100).length);*/
/*CreateArray c = ( length)-> new int[length];;
System.out.println(c.cre(100).length);*/
CreateArray c = int[]::new;;
System.out.println(c.cre(100).length);以上是我在学习中对lambda表达式的总结，希望对小伙伴们的学习有所帮助。