JDK1.8 Lambda 表达式的学习

布满荆棘的人生 2022-04-06 04:48 177阅读 0赞

## 1、Lambda  表达式 ##

Lambda 表达式（也称为闭包）是整个Java8发行版本中最受期待的在Java语言层面上的改变，Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据，Lambda 表达式用于简化Java中接口式的匿名内部类，被称为函数式接口的概念，函数式接口就是一个具有一个方法的普通接口，像这样的接口，可以被隐式转换为Lambda 表达式。

**语法：**

**（参数1，参数2...）->(...)**

（1）没有参数的时候使用Lambda 表达式

（2）带参数时使用Lambda 表达式

（3）代码块中只一句代码时使用Lambda 表达式

（4）代码块中有多句代码时使用Lambda 表达式

（5）有返回值的代码块

（6）参数中使用final 关键字

/**
     * @Date: 2018/12/8 10:23
     * @Description:
     */
    public class LambdaDemo {
    
    //    public static void main(String args[]) {
    //        IEat iEat = new IEatImpl();
    //        iEat.eat();
    //
    //        //匿名内部类的使用
    //        IEat iEat1 = new IEat() {
    //            public void eat() {
    //                System.out.println("eat banana");
    //            }
    //        };
    //        iEat1.eat();
    //
    //        //Lambda 表达式
    //        //好处：1.代码更加的简介；2.不会单独生成class文件
    //        //一个接口中只有一个方法的时候能使用Lambda 表达式
    //        //如果一个接口有多个方法就不能使用Lambda 表达式，只能用传统的匿名内部类
    //        //IEat iEat2 = () ->{ System.out.println("eat peach");};
    //
    //        //没有参数时候的使用
    //        IEat iEat2 = () -> System.out.println("eat peach");
    //        iEat2.eat();
    //    }
    
        public static void main(String args[]) {
    
            //1.带参数时使用，参数的类型可以省略
    //        IEat iEat = (thing,name) -> System.out.printf("eat:", thing + "...." + name);
    //        iEat.eat("apple","anf");
    
            //2.带参数时使用，参数的类型可以省略，代码中有多行参数
    //        IEat iEat = (thing,name) -> {
    //            System.out.printf("eat:", thing);
    //            System.out.println(name);
    //        };
    //        iEat.eat("apple","anf");
    
            //3.带返回值的方法
    //        IEat iEat = (thing , name) ->{
    //            System.out.println(name + "eat" + thing);
    //            int i = 10;
    //            return i;
    //        };
    //        iEat.eat();
    
            //4.带返回值的方法中只有一句实现代码
    //        IEat iEat = (thing , name) -> thing == null?1:0;
    //        iEat.eat();
    
            //5.参数中使用final 关键字
    //        IEat iEat = (final String thing ,final String name) -> thing == null?1:0;
    //        iEat.eat();
        }
    }
    
    //只有一个抽象方法的接口
    interface IEat{
        public void eat();
    
        public void eat(final String thing,final String name);
    }
    
    //实现类
    class IEatImpl implements IEat{
    
        public void eat() {
            System.out.println("eat apple");
        }
    
        @Override
        public void eat(String thing,String name) {
            System.out.println("string thing");
        }
    }

2.接口中的默认方法和静态方法

interface A{
       public default void print(){};
       public static void method(){};
    }

默认方法与静态方法并不影响函数式接口的契约，可以任意使用。

package demo;
    
    import lombok.Data;
    
    /**
     * @Date: 2018/12/8 11:14
     * @Description:
     */
    @Data
    public class Student {
    
        private String name;
        private Integer age;
    
        public Student(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
    }

import demo.Student;
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    /**
     * @Date: 2018/12/8 10:23
     * @Description:
     */
    public class LambdaDemo {
    
        public static void main(String args[]) {
    
    
            //排序
            //Comparator<Student> comparator = (o1,o2) ->o1.getAge() - o2.getAge();
            Arrays.sort(students,(o1,o2) ->o1.getAge() - o2.getAge());
            System.out.println(Arrays.toString(students));
        }
    }
    
    //只有一个抽象方法的接口
    interface IEat{
        public void eat();
    
        public void eat(final String thing,final String name);
    
        //默认方法, 默认方法与静态方法并不影响函数式接口的契约，可以任意使用。
        public default void print(){
            System.out.println("print test");
        }
    
        //静态方法 ，默认方法与静态方法并不影响函数式接口的契约，可以任意使用。
        public static void method(){
            System.out.println("static method");
        }
    
    }
    
    //实现类
    class IEatImpl implements IEat{
    
        public void eat() {
            System.out.println("eat apple");
        }
    
        @Override
        public void eat(String thing,String name) {
            System.out.println("string thing");
        }
    }