6.2JavaJDK8当中特性--->lambda表达式

Lambda表达式图示

作用

• 主要用于简化多线程的时候线程使用次数比较少的情况

有点：

• 只需要关注线程体--->功能

• 不需要关注线程类和结构，用于简化

推导lambda--->接口不带形参，无返回值

package iostudy.thread;
​
/**
 * Lambda表达式，简化线程(用一次)的使用
 * @since JDK 1.8
 * @date 2021/6/2
 * @author Lucifer
 */
public class LambdaThread {
​
    /**
     * 静态内部类
     * 只使用一次
     */
    static class Test implements Runnable{
​
        /**
         * 线程入口点
         */
​
        @Override
        public void run(){
            /*循环编码*/
            for (int i = 0; i < 20; i++){
                System.out.println("Always Coding");
            }
        }
    /*
    一个类如果用一次为了提升性能可以作为内部类
    不会随着程序的运行而加载，只会随着使用而进行加载
    不会编译
     */
    }
​
    public static void main(String[] args) {
​
        /**
         * 局部内部类
         */
        class Test2 implements Runnable{
​
            /**
             * 线程入口点
             */
            @Override
            public void run(){
                /*循环编码*/
                for (int i = 0; i < 20; i++){
                    System.out.println("Always Coding");
                }
            }
            /*
            一个类如果用一次为了提升性能可以作为内部类
            不会随着程序的运行而加载，只会随着使用而进行加载
            不会编译
             */
        }
        /*实例化代理类内部实例化节点类*/
        new Thread(new Test2()).start();
​
        /*匿名内部类。匿名内部类使用必须借助接口或者父类*/
        new Thread(new Runnable() {
            /*因为接口不能实例化，所以这个花括号内部写的是具体的实现*/
​
            /*重写run方法*/
            @Override
            public void run(){
                /*循环编码*/
                for (int i = 0; i < 20; i++){
                    System.out.println("Always Coding");
                }
            }
        }).start();
        /*
        匿名内部类的意思：
        1、没有了实现类的对象名称
        2、没有子类的名称
        3、只用父类或者接口带上线程体--->因为接口不能实例化(实现体(类体))
         */
​
        /**
         * 因为匿名内部类里面写具体实现在流程复杂以后会写很多
         * 所以使用了JDK 8当中的lambda方法
         * @since JDK 1.8
         */
        new Thread(()->{
            /*循环编码*/
            for (int i = 0; i < 20; i++){
                System.out.println("Always Coding");
            }
        }).start();
        /*
        删掉了接口名
        删掉了方法名
        只需要关注参数和实现。
        适用于较简单的线程体--->用于简化简单的线程类
         */
        /*
        lambda特点：
        接口里面只能由一个方法，有多个方法无法推到
         */
    }
    /*
    好处：
    1、如果内部类不使用，那么该类不会编译
     */
    /*
    1、最初的外部类
    2、静态内部类
    3、局部内部类
    4、匿名内部类
    5、lambda内部类
     */
}

lambda的推到--->接口不带形参，无返回值

package iostudy.thread;
​
/**
 * lambda表达式的推到
 * @since JDK 1.8
 * @date 2021/6/2
 * @author Lucifer
 */
public class LambdaTestNo1 {
​
    /*定义成内部类*/
    /*定义实现类，实现lambda*/
    static class Like2 implements like{
​
        /*重写接口方法*/
        @Override
        public void lambda(){
            System.out.println("I like lambda!!!");
        }
    }
​
    public static void main(String[] args) {
​
        /*实例化实现类对象*/
        Like like = new Like();
​
        like = new Like( );
​
        /*调用实现类的lambda方法*/
        like.lambda();
​
        /*第三种调用方法*/
        like = new Like(){
            public void lambda(){
                System.out.println("I like lambda3!!!");
            }
        };
​
        //lambda表达式
        like like1 = ()->{
            System.out.println("I like lambda3!!!");
        };
    }
}
​
/*定义内部接口*/
interface like{
​
    /*定义接口内部方法*/
    void lambda();
​
}
​
/*定义实现类，实现lambda*/
class Like implements like{
​
    /*重写接口方法*/
    @Override
    public void lambda(){
        System.out.println("I like lambda!!!");
    }
}

特点：

lambda推到必须存在类型--->因为接口当中定义了泛型

lambda推演--->接口带形参，无返回值

package iostudy.thread;
​
/**
 * Lambda推到+参数
 * @since JDK 1.8
 * @date 2021/6/3
 * @author Lucifer
 */
public class LambdaTestNo2 {
    public static void main(String[] args) {
        /*使用lambda表达式去简化输出*/
        ILove love = (int a) -> {
            System.out.println("Lambda is:" + a);
        };
​
        /*如果只有一个参数，括号可以省略。如果多个参数，数据类型可以省略--->因为接口当中的形参定义了类型*/
        ILove love1 = (a) -> {
            System.out.println("Lambda is:" + a);
        };
​
        /*只有一个参数，省略括号*/
        ILove love2 = a -> {
            System.out.println("Lambda is:" + a);
        };
​
        /*如果重写内容只有一行代码，花括号可以省略*/
        ILove love3 = a -> System.out.println("Lambda is:" + a);
​
        /*调用一下*/
        love.lambda(100);
        love1.lambda(50);
        love2.lambda(5);
        love3.lambda(0);
    }
}
​
/**
 * 定义一个接口
 */
interface ILove{
​
    /*里面放一个方法*/
    void lambda(int a); //方法定义形参
}
​
/**
 * 定义一个外部类，实现接口，重写方法
 */
class Love implements ILove{
​
    /*重写接口方法*/
    @Override
    public void lambda(int a){
        System.out.println("Lambda is:" + a);
    }
}

lambda推演--->接口带形参，有返回值

package iostudy.thread;
​
/**
 * Lambda推到+参数+返回值
 * @since JDK 1.8
 * @date 2021/6/3
 * @author Lucifer
 */
public class LambdaTestNo3 {
    public static void main(String[] args) {
​
        /*lambda表达式使用*/
        IInterest interest = (int first, int second) -> {
            System.out.println("lambda is:" + (first + second));
            int total = (first + second);
            return total;
        };
​
        IInterest interest1 = (first, second) -> {
            System.out.println("lambda is:" + (first + second));
            int total = (first + second);
            return total;
        };
​
        /*如果只有一行返回值，可以直接简化成结果*/
        IInterest interest2 = (first, second) -> {
            return first + second;
        };
​
        /*启动*/
        interest.lambda(100, 200);
        interest1.lambda(200, 300);
        interest2.lambda(300, 400);
    }
}
​
/**
 * 定义一个有返回值的接口
 */
interface IInterest{
​
    /*定义有返回值的方法*/
    public abstract int lambda(int a, int b);
}
​
/**
 * 定义一个外部类，该外部类实现接口并且重写方法
 */
class Interest implements IInterest{
​
    /*重写接口当中的方法*/
    public int lambda(int first, int second){
        System.out.println("lambda is:" + (first + second));
        int total = (first + second);
        return total;
    }
}

lambda表达式实质

• 避免匿名内部类使用过多

• 其实质是函数式编程

  (params) -> expression
  (params) -> statement
  (params) -> (statements)
  //简单的多线程或者匿名内部类的地方使用lambda表达式

•