lambda表达式

Mr.乐.

已于 2022-08-23 16:44:28 修改

阅读量665

点赞数 13

文章标签： java intellij-idea

于 2022-08-23 15:58:35 首次发布

本文链接：https://blog.csdn.net/zdl66/article/details/126479221

版权

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表达式的总结，希望对小伙伴们的学习有所帮助。

Mr.乐.

关注

13
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
16
评论
lambda表达式

lambda表达式是JAVA8中提供的一种新的特性，它支持JAVA也能进行简单的“函数式编程”。它是一个匿名函数。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，它在实现接口的时候不会生成class文件，大大提升了编译时的效率。
复制链接

扫一扫