（java总结）Lambda

迈不过友情╰ 2023-06-12 09:51 1阅读 0赞

package Demo40;
    /*
    Lambda表达式的标准格式：
        有三部分组成：
            1、一些参数
            2、一个箭头
            3、一段代码
        格式：
            (参数列表) -> {
        一些重写方法的代码};
        解释格式说明：
            ():接口中的方法的参数列表，没有参数就空着，有参数就写出参数，多个参数使用逗号分隔
            ->:传递的意思，把参数传递给方法体{
        }
            {
        }:重写接口中的方法的方法体
    
    Lambda的使用前提
        1、使用Lambda必须具有接口，且要求接口中有仅且有一个抽象方法
            无论是JDK的内置Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时
            才可以使用Lambda
        2、使用Lambda必须具有上下文推断
            也就是方法的参数或者局部变量必须为Lambda对应的接口类型，才可以使用Lambda作为改接口的实例
    
         备注： 有且仅有一个抽象方法的接口，称为函数式接口
     */
    public class DemoLambda {
        
        public static void main(String[] args) {
        
            //使用匿名内部类的方式，实现多线程
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "11新线程创建了");
                }
            }).start();
    
            //使用Lambda表达式，实现多线程
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + "新线程222创建了");
            }
            ).start();
        }
    }

package Demo40;
    /*
    使用实现Runnable接口的方法实现多线程程序
     */
    public class DemoRunnable {
        
        public static void main(String[] args) {
        
            //创建Runnable接口的实现类对象
            RunnableImpl run = new RunnableImpl();
            //创建Thread类对象，构造方法中传递Runnable接口垫额实现类
            Thread t = new Thread(run);
            t.start();
    
            //简化代码，使用匿名内部类，实现多线程程序，不需要再创建一个类
            Runnable r = new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "11新线程创建了");
                }
            };
            new Thread(r).start();
    
    
        }
    }

package Demo40;
    
    public class RunnableImpl implements Runnable {
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName() + "新线程创建了");
        }
    }

package Demo40;
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    /*
    Lambda表达式有参数有返回值的练习
    需求：
        使用数组存储多个Person对象
        对数组中Person对象使用Arrays的sort方法通过年龄进行排序
     */
    public class DemoLambdaArrays {
        
        public static void main(String[] args) {
        
            //使用数组存储多个Person对象
           Person[] arr = {
         new Person("柳岩",18),
                            new Person("古力娜扎",25),
                            new Person("迪丽热巴",26)
    
           };
    
           // 对数组中Person对象使用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);
            }
        }
    }

package Demo40;
    
    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 String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }

package Demo40;
    /*
    需求：
        给定一个厨子Cook接口，内含唯一的抽象方法makeFood,且无参数，无返回值
        使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭了~"字样
     */
    public class DemoLambdaCook {
        
        public static void main(String[] args) {
        
                invokeCook(new Cook() {
        
                    @Override
                    public void makeFood() {
        
                        System.out.println("吃饭了");
                    }
                });
    
            invokeCook(() -> System.out.println("吃饭了"));
        }
    
        //定义一个方法，参数传递Cook接口，方法内部调用Cook'接口中方法makeFood
        public static void invokeCook(Cook cook){
        
            cook.makeFood();
        }
    }

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

package Demo40;
    /*
    lambda表达式有参数有返回值的练习
    需求：
        给定一个计算器Calculator接口，内含抽象方法calc可以将两个数字相加的到和
        使用Lambda的标准格式调用invokeCalc方法，完成10和0的相加计算
     */
    public class DemoCalculator {
        
        public static void main(String[] args) {
        
            //
            invokeCalc(10, 20, new Calculator() {
        
                @Override
                public int calc(int a, int b) {
        
                    return a+b;
                }
            });
    
            //使用Lambda表达式来简化匿名内部类的书写
            invokeCalc(10,20,(int a, int b)->{
        
                return a+b;
            });
        }
    
        /*
        定义一个方法
        参数传递俩个int类型的整数
        传递参数Calculator中的方法calc计算两个数的和
         */
        public static void invokeCalc(int a, int b, Calculator c){
        
            int sum = c.calc(a,b);
            System.out.println(sum);
        }
    }

package Demo40;
    /*
    给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和指
     */
    public interface Calculator {
        
        public abstract int calc(int a, int b);
    }

package Demo40;
    /*
    Lambda表达式：是可推导，可以省略
    可以省略的内容：
        1、(参数列表)：括号中参数列表的数据类型，可以省略不写
        2、(参数列表)：括号中的参数如果只有一个，那么类型和()都可以省略
        3、{
        一些代码}：如果{
        }中的代码只有一行，无论是否有返回值，都可以省略({
        },return,分号)
                            注意：要省略{
        },return,分号必须一起省略
     */
    public class Lambda {
        
    }