Java的lambda表达式

lambda表达式

• 希腊字母表中排序第十一位的字母，英文名Lambda。

• 为什么要使用lambda表达式

  • 避免匿名内部类定义过多

  • 可以让你的代码看起来很简洁

  • 去掉了没有意义的代码，只留下核心的逻辑。

• 其实质属于函数式编程的概念，它出现就是为了简化代码。

  • (params) -> expression [表达式]

  • (params) -> statement [语句]

  • (params) -> { statements }

• a -> System.out.println ("i like lambda -->" + a);

• new Thread (() -> System.out.println("多线程学习...")).start();

---

• 理解Functional interface(函数式接口) 是学习Java8的lambda表达式的关键所在

• 函数式接口的定义

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

  • public interface Runnable{
        public abstract void run();
    }
    //=============================================//

  • package com.kuang.lambda;
    /*
        推导lambda表达式
     */
    ​
    public class TestLambda1{
        //3.静态内部类
        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();
            like.lambda();
            
            like = new like2(); //已定义ILIke like
            like.lambda();
            
            //4.局部内部类
            class Like3 implements ILike{
                @Override
                public void lambda(){
                    System.out.println("i like lambda3");
                }
            }
            like = new Like3();
            like.lambda();
            
            //5.匿名内部类，没有类的名称，必须借助接口或者父类，且两者都要重写它的方法。
            //匿名内部类等于不重起接口名或者类名去继承父类，直接去重写接口或者父类的方法。
            like = new ILike(){
                @Override
                public void lambda(){
                    System.out.println("i like lambda4");
                };
                like.lambda();
                
                //6.用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表达式来创建该接口的对象。

package com.kuang.lambda;
​
public class TestLambda{
    public static void main(String[] args){
        //ILove love = new Love();
        //love.love(2);
        //匿名内部类，这个类new出来之后没有名字，这个接口有名字。
        ILove love = new ILove(){
            @Override
            public void love(int a){
                System.out.println("I love you-->" + a);
            }
        };
        love.love(2);
        
        //lambda表达式
        ILove love = (int a)->{
            System.out.println("I love you-->" + a);
        };
        love.love(520);
        
        //1.lambda表达式简化一：去掉参数类型
        love = (a)->{
            System.out.println("I love you-->" + a);
        };
        love.love(520);
        //简化二：去掉括号
        //此处单独用需提前定义ILove love = null;是接口引用
        love = a->{
            System.out.println("I love you-->" + a);
        };
        love.love(520);
        //简化三：去掉花括号
        //使用前提：lambda表达式只有一行代码的情况下才能使用
        //此处单独用需提前定义ILove love = null;是接口引用
        love = a->System.out.println("I love you-->" + a);
        love.love(520);
    }
}
​
interface ILove{
    void love(int a);
}
/**
 *   class Love implements ILove{
 *       @Override
 *       public void love(int a){
 *           System.out.println("i love you-->" + a);
 *       }
 *   }
 */

• 总结

  • lambda表达式只能有一行代码的情况下才能简化称为一行，如果有多行，那么只能用代码块包裹。

  • 使用前提是接口必须为函数式接口（接口里只有一个抽象方法，因为接口里方法都是抽象的，等价于只有唯一一个方法。）

  • 多个参数传入时使用lambda，也可以去掉参数类型，要去掉就都去了，用括号括起来参数间再用逗号间隔就行了。

• 实例化一个空值对象，给对象的赋值却不留原接口名，不留原方法名，只留一个方法参数和代码块的代码，最后调用它的方法就可以实现lambda表达式了。

•