Lambda表达式详解_labmda 表达式参数-CSDN博客

本文链接：https://blog.csdn.net/weiyoo55/article/details/107296453

01：Lambda表达式

Lambda表达式标准格式：

由三部分组成：
a.一些参数
b.一个箭头
c.一段代码
格式：
（参数列表） ->{ 一些重写方法的代码};
解释说明格式：
（）：接口中抽象方法的参数列表，没有参数，就空着;有参数就写出参数，多个参数使用逗号分隔，
->:传递的意思，把参数传递给方法体{}
{}：重写接口的抽象方法的方法体

package com.Lambda;

/*
    Lambda表达式标准格式：
         由三部分组成：
              a.一些参数
              b.一个箭头
              c.一段代码
          格式：
              （参数列表） ->{ 一些重写方法的代码};
          解释说明格式：
              （）：接口中抽象方法的参数列表，没有参数，就空着;有参数就写出参数，多个参数使用逗号分隔
               ->:传递的意思，把参数传递给方法体{}
               {}：重写接口的抽象方法的方法体

 */
public class Demo02Lambda {
    public static void main(String[] args) {
       //使用匿名内部类的方式实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新线程创建了");
            }
        }).start();
       //使用Lambda表达式，实现多线程
        new Thread(() ->{
                System.out.println(Thread.currentThread().getName() + "新线程创建了");
            }
            ).start();
    }
}

02：Lambda表达式无参数无返回值案例

需求：

给定一个厨子Cook接口，内含唯一的抽象方法makeFood,且无参数、无返回值。
使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样

package com.Lambda;
/*
    需求：
         给定一个厨子Cook接口，内含唯一的抽象方法makeFood,且无参数、无返回值。
         使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样
 */
public class Demo03Cook {
    public static void main(String[] args) {
       //调用invokeCoke方法,参数是Cook接口，传递Cook接口的匿名内部类对象
        invokeCoke(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭啦");
            }
        });

        //使用Lambda表达式，简化匿名内部类的书写
        invokeCoke(()->{
            System.out.println("吃饭啦");
        }); 
    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCoke(Cook cook){
      cook.makeFood();
    }
}

Cook接口

package com.Lambda;
  /*
      定义一个Cook接口，内含唯一的抽象方法makeFood
   */
public interface Cook {
    //定义无参数无返回值的方法makeFood
      public abstract void makeFood();
}

03：Lambda表达式有参数有返回值案例

lambda表达式有参数有返回值的练习
需求：

使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

package com.Lambda;


import java.util.Arrays;
import java.util.Comparator;

/*
   lambda表达式有参数有返回值的练习
   需求：
        使用数组存储多个Person对象
        对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
 */
public class Demo04Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("柳岩",39),
                new Person("杨幂",29),
                new Person("迪丽热巴",26)
        };
         //对数组中的Person对象使用Arrays对象使用Arrays的sort方法通过年龄进行升序（前边-后边）排序
//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });

        //使用Lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person o1,Person o2) ->{return o1.getAge()-o2.getAge(); } );

        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

Person类

package com.Lambda;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

04：Lambda表达式有参数有返回值案例（自定义接口）

Lambda表达式有参数有返回值的练习
需求：

给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

package com.Lambda;
  /*
    Lambda表达式有参数有返回值的练习
    需求：给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
          使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
   */
public class Demo05Calculator {
    public static void main(String[] args) {
    //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
      invokeCalc(120, 130, new Calculator() {
        @Override
        public int calc(int a, int b) {
          return a+b;
        }
      });

    //使用Lambda表达式简化匿名内部类的书写
    invokeCalc(120,130,(int a,int b)->{return a+b;});
    }
    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法调用Calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
      int sum = a + b;
      System.out.println(sum);
    }
}

计算器Calculator接口

package com.Lambda;
 /*
    给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
  */
public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
     public abstract int calc(int a,int b);
}

05：Lambda表达式省略格式

Lambda表达式：是可推导，可以省略

凡是根据上下文推导出来的内容，都可以省略书写
可以省略的内容
1.(参数列表）：括号中参数列表的数据类型吗，可以省略不写
2.（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
3.{一些代码}:如果{}中的代码只有一行，无论是否有返回值，都可以省略{}，return,分号;）
注意：要省略{},return,分号;必须一起省略

package com.Lambda;

import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import java.util.ArrayList;

/*
      Lambda表达式：是可推导，可以省略
      凡是根据上下文推导出来的内容，都可以省略书写
      可以省略的内容
           1.(参数列表）：括号中参数列表的数据类型吗，可以省略不写
           2.（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
           3.{一些代码}:如果{}中的代码只有一行，无论是否有返回值，都可以省略{}，return,分号;）
                注意：要省略{},return,分号;必须一起省略
 */
public class Demo06ArrayList {
    public static void main(String[] args) {
        //在JDK1.7之前，创建集合对象必须把前后的泛型都写上
        ArrayList<String> list01 = new ArrayList<String>();

        //在JDK1.7版本之后，=号后边的泛型可以省略，后边的泛型可以根据前边的泛型推导出来
        ArrayList<String> list02 = new ArrayList<>();
    }
}

package com.Lambda;
public class Demo02Lambda {
    public static void main(String[] args) {
       //使用匿名内部类的方式实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新线程创建了");
            }
        }).start();
       //使用Lambda表达式，实现多线程
        new Thread(() ->{
                System.out.println(Thread.currentThread().getName() + "新线程创建了");
            }
            ).start();
        //优化省略Lambda
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "新线程创建了")).start();
    }
}

package com.Lambda;

public class Demo03Cook {
    public static void main(String[] args) {
       //调用invokeCoke方法,参数是Cook接口，传递Cook接口的匿名内部类对象
        invokeCoke(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭啦");
            }
        });

        //使用Lambda表达式，简化匿名内部类的书写
        invokeCoke(()->{
            System.out.println("吃饭啦");
        });

        //优化省略Lambda
        invokeCoke(()-> System.out.println("吃饭啦"));
    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCoke(Cook cook){
      cook.makeFood();
    }
}

package com.Lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Demo04Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("柳岩",39),
                new Person("杨幂",29),
                new Person("迪丽热巴",26)
        };
         //对数组中的Person对象使用Arrays对象使用Arrays的sort方法通过年龄进行升序（前边-后边）排序
//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });

        //使用Lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person o1,Person o2) ->{return o1.getAge()-o2.getAge(); } );

        //优化省略Lambda
        Arrays.sort(arr,(o1, o2) ->o1.getAge()-o2.getAge());

        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

package com.Lambda;

public class Demo05Calculator {
    public static void main(String[] args) {
    //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
      invokeCalc(120, 130, new Calculator() {
        @Override
        public int calc(int a, int b) {
          return a+b;
        }
      });

    //使用Lambda表达式简化匿名内部类的书写
    invokeCalc(120,130,(int a,int b)->{return a+b;});

    //优化省略Lambda
        invokeCalc(120,130,(a,b)-> a+b);
    }

    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法调用Calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
      int sum = a + b;
      System.out.println(sum);
    }
}

06:Lambda使用前提

Lambda表达式使用前提

1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda
2.使用Lambda必须具有上下文推断
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口.称为"函数式编程"