Lambda表达式

Lambda表达式

让我们先来看一下一般的函数

int add(int a,int b){
		return a+b;
}

普通函数 有返回类型，方法名，参数列表，方法体

---

以下是Lambda表达式：

(int a,int b) -> {return a+b;};//注意分号的位置，这本质上是一个函数

Lambda表达式对比普通的函数我们可以清楚的看到：

Lambda表达式函数，只有参数列表，和方法体（参数列表） ->{方法体};

• 说明：

  • （）：用来描述参数列表；

  • { } : 用来描述方法体；

  • -> : Lambda运算符，可以叫做箭头符号，或者goes to

• 想要用Lambda表达式的前提连接的必须是一个函数式接口：

  • 函数式接口定义：任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口

public interface Runnable{
		public abstract void run();//只有一个方法 在接口里面的函数自动定义为public abstract
}

---

演示一下Lambda表达式的推演过程

package lambda;

public class TestLambda1 {
    //3、静态内部类，需要加static修饰符
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();//用接口new一个实现类
        like.lambda();//调用实现类里面的函数

        like = new Like2();//静态内部类的实现，不需要依赖外部类的对象
        like.lambda();


        //4、局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }

        like = new Like3();
        like.lambda();

        //5、匿名内部类,没有类的名称，new的是一个接口 必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };//注意这里需要分号 因为这里是一行语句

        like.lambda();

        //6、再简化JDK1.8出来的，用Lambda简化
        like = ()->{
            System.out.println("i like lambda5");
        };
        like.lambda();
    }
}


//1、定义一个函数式接口
interface ILike{
    void lambda();
}

//2、实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

---

看到这里，大家是不是感觉Lambda表达式很精简啊？ 别急， 还有更骚的操作！！！

Lambda表达式精简语法：

1、参数类型可以省略

If if=(a,b)->{					//If 是接口
		System.out.println("省略两个参数类型 a+b="+(a+b));
};

2、假如只有一个参数，（）括号可以省略

If if=a->{
		System.out.println("只有一个参数时可以省略括号（）");
};

3、如果方法体只有一条语句，{ }大括号可以省略

If if=a->System.out.println("只有一条语句时可以省略大括号{}");

4、如果方法体中唯一的语句是return返回语句，那省略大括号的同时return也要省略

/*
If if=a->{
		return a;
};
以上代码改写后如下
*/
If if=a->a；

---

Lambda表达式方法引用

package lambda;

public class Program01 {
    public static void main(String[] args) {
        /*Itface itface = (a)->{
            return a-2;
        };
        以上代码可简化为以下代码
        */
        Itface itface1 = a-> a-2;//这样是不是很清爽？
        System.out.println(itface1.test(3));

        Itface itface2 = a-> a-2;//发现一个问题：如果这里面的方法需要重复改动，会非常麻烦。现在只是两个，如果代码量很大 假设有100个我们就需要该100次
        System.out.println(itface2.test(5));

    }
}


interface Itface{
    int test(int a);
}

发现上面的代码很有局限性，死板，不灵活，这时候的话我们可以通过定义一个通用函数实现，然后再去调用它。我们来看以下代码有何不同。

package lambda;

public class Program01 {
    public static void main(String[] args) {
        Program01 program01 = new Program01();

        Itface itface1 = program01::testA;
        System.out.println(itface1.test(3));

        Itface itface2 = program01::testA;
        System.out.println(itface2.test(5));

    }

    public int testA(int a){//如果这里的函数是静态static 在主函数里我们都不需要new对象了  直接就可以调用到这个函数
        return a-2;
    }
}


interface Itface{
    int test(int a);
}