lambda表达式的简单使用

新时代程序员必须掌握：lambda 表达式、链式编程、函数式接口、Stream 流式计算

lambda表达式的简单实现

概念

• λ 希腊字母表中排序第十一位的字母，英语名称为 Lamda。
• 可以用来避免匿名内部类定义过多。
• 其实质属于函数式编程的概念。（也就是说必须是函数式接口才能使用lambda表达式）

函数式接口定义

任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。

//如下方多线程Runnable接口就是一个函数式接口
public interface Runnable{
    public abstract void run();
}

示例1：我们来演示各种调用接口实现类的方法（观察如何从复杂到简单）

正常调用

public class LambdaExample01 {
    public static void main(String[] args) {
        ILike like = new Like();
        like.lamda();
    }
}
// 1.定义一个函数式接口
interface ILike {
    void lamda();
}
// 2.实现类
class Like implements ILike {
    @Override
    public void lamda() {
        System.out.println("I like lambda");
    }
}

静态内部类方式的调用

public class LambdaExample02 {
    //2. 静态内部类
    static class Like implements ILike {
        @Override
        public void lamda() {
            System.out.println("I like lambda");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lamda();
    }
}
// 1.定义一个函数式接口
interface ILike {
    void lamda();
}

局部内部类方式调用

public class LambdaExample03 {
    public static void main(String[] args) {
        //2.局部内部类
        class Like implements ILike {
            @Override
            public void lamda() {
                System.out.println("I like lambda");
            }
        }
        ILike like = new Like();
        like.lamda();
    }
}
// 1.定义一个函数式接口
interface ILike {
    void lamda();
}

匿名内部类的调用

public class LambdaExample04 {
    public static void main(String[] args) {
        //2.匿名内部类,没有类的名称,必须借助接口或者父类
        ILike like = new ILike() {
            @Override
            public void lamda() {
                System.out.println("I like lambda");
            }
        };
        like.lamda();
    }
}
// 1.定义一个函数式接口
interface ILike {
    void lamda();
}

lambda方式调用

public class LambdaExample05 {
    public static void main(String[] args) {
        //2.lamda简化
        ILike like = () ->{
            System.out.println("I like lambda");
        };
        like.lamda();
    }
}
// 1.定义一个函数式接口
interface ILike {
    void lamda();
}

示例2：带有参数的函数式接口

public class LambdaExample06 {
    public static void main(String[] args) {
        ILove love=null;
         // 1.lambda 带有参数类型的写法
        love = (int a) -> {
            System.out.println("I love you -->" + a);
        };
        // 2.lambda简化1 不需要带有参数类型
        love = (a) -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lambda简化2 把括号去掉 （如果有多个参数就不能去掉括号）
        love = a -> {
            System.out.println("I love you -->" + a);
        };
        // 4.lambda简化 如果只有一行语句可以去掉{}
        love = a -> System.out.println("I love you -->" + a);

        /**总结:
         * {}简略的条件是只能有一行代码,多行{}就不能简略了
         * 前提是接口为函数式接口(只能有一个方法)
         * 多个参数也可以去掉参数类型,要去掉就都去掉,但必须加上()
         */
        love.love(520);
    }
}

interface ILove {
    void love(int a);
}

使用场景：因为Runable接口也是函数式接口，所有可以使用lambda表达式。

//Thread implements Runnable（源码）
new Thread (()->System.out.println("多线程学习。。。。")).start();

参考课程：狂神学java