Lambda表达式java实现

解释都在注释中

基本概念以及用法

package Demo16Lambda;

/**
 * 使用lambda表达式可以对一个接口进行非常简洁的实现
 *
 * 虽然可以使用lambda表达式对某些接口进行简单的实现，但是并不是所有的接口都可以
 * 用lambda表达式来实现，要求接口中定义的必须从要实现的抽象方法只能是一个。
 *
 * 在jdk8中接口新加了一个特性，default。
 *
 * @FunctionlIntyerface
 * 修饰函数式接口，接口中的抽象方法只有一个。
 */
public class lambda {
    public static void main(String[] args) {
        /**
         * 接口不能实例化，用接口的实现类可以实例化，
         *  将实现类的对象在内存中的地址指向接口，这个接口就可以使用了
         *
         *  但是不能使用实现类中有但是接口所没有的方法，
         *  包括实现类没有重写的方法
         */
        //1.使用接口实现
        Comparator comparator = new mycompartor();
//        comparator.compartoor(12,15);
//        comparator.jiekou();

        //2.使用匿名内部类
        Comparator  comparator1 =new Comparator() {
            @Override
            public int compartoor(int a, int b) {
                return a-b;
            }
        };

        //3.使用lambda表达式,可以非常简洁的对一个接口进行实现
        Comparator comparator2 = ((a, b) -> a-b);
    }
}



class mycompartor implements Comparator{

    @Override
    public int compartoor(int a, int b) {
        return a-b;
    }
    public void shixain(){
        System.out.println("this is a shixian");
    }
}

@FunctionalInterface
interface Comparator{
    int  compartoor(int a,int b);

    default void jiekou(){
        System.out.println("this is a jiekou");
    }
}

定义六个接口，表示出具体用法

实现

package Demo16Lambda.syntax;

import Demo16Lambda.interfaces.*;

public class Syntax1 {
    //1.lambda表达式的基本语法；
    //lambda是一个匿名函数
    //参数列表，方法体

    //（）：用来描述参数列表
    //{}：用来描述方法体
    // -> lambda运算符，读作goes to



    public static void main(String[] args) {
        //无参无返回
        LambdaNoneReturnNoneParamter lambda1 =()->{
            System.out.println("hello");
        };
        lambda1.test();

        //无返回值单个参数
        LambdaNoneReturnSingleParamter lambda2=(int a)->{
            System.out.println(a);
        };
        lambda2.test(10);

        //无返回值多个参数
        LambdaNoneReturnMutipleParameter lambda3=(int a ,int b)->{
            System.out.println(a+b);
        };
        lambda3.test(12,55);


        //无参有返回
        LambdaSingleReturnNoneParameter lambda4=()->{
            System.out.println("lambda4");
            return  100;
        };
        int test = lambda4.test();
        System.out.println(test);

        //有返回值单个参数
        LambdaSingleReturnSingleParameter lambda5=(int a )->{
            System.out.println("lambda5");
            return  a*2;
        };
        int test1 = lambda5.test(500);
        System.out.println(test1);

        //有返回值多个参数
        LambdaSingleReturnMutipleParameter lambda6=(int a,int b )->{
            return  a*2+b*4;
        };
        int test2 = lambda6.test(500,100);
        System.out.println(test2);
    }

}

简写

package Demo16Lambda.syntax;

import Demo16Lambda.interfaces.*;

/**
 * 语法精简
 * 1.参数
 *  由于在接口的抽象方法中，已经定义了参数的数量和类型，所以在lambda表达式中参数的类型可以省略
 *    备注：如果需要省略类型，则每一个参数的类型都需要省略。
 */
public class Syntax2 {
    public static void main(String[] args) {

        LambdaSingleReturnMutipleParameter lambda1= (a,b)->{
            System.out.println("xixixi");
            return a*2+5*b;
        };
        System.out.println(lambda1.test(12,55));

        /**
         * 2.小括号
         * 如果参数列表中，参数的数量只有一个，此时小括号可以省略
         */
        LambdaSingleReturnSingleParameter lambda2 = a -> {
            System.out.println("hshhh");
            return a*5;
        };
        System.out.println(lambda2.test(44));


        /**
         * 方法大括号
         *  如果方法体中只有一条语句，此时大括号可以省略
         */
        LambdaNoneReturnSingleParamter lambd3= a ->System.out.println("asdasd");

        /**
         * 如果方法体中唯一一条语句是返回值,在省略掉大括号中的同时必须省略return
         */
        LambdaSingleReturnNoneParameter lambda4 = () ->10;
    }
}

简写2

package Demo16Lambda.syntax;

import Demo16Lambda.interfaces.LambdaSingleReturnSingleParameter;

public class Syntax3 {
    public static void main(String[] args) {
        //方法引用
        //可以快速的将一个Lambda表达式的实现指向一个已经实现的方法
        //语法： 方法的隶属者 ：：方法名
        //注意:1.参数数量和类型一定要和接口中定义的方法一致
        //     2.返回值的类型一定 要和接口中定义的方法一致
        LambdaSingleReturnSingleParameter lambda1 =a -> change(a);

        LambdaSingleReturnSingleParameter lambda2 =Syntax3::change;
    }

    private static int change(int a) {
        return a*2;
    }
}

构造方法的引用

package Demo16Lambda.syntax;

import Demo16Lambda.data.Person;

/**
 *
 *
 */
public class Syntax4 {
    public static void main(String[] args) {

        PersonCreater personCreater =()->new Person();
        //构造方法的引用

        PersonCreater creater= Person::new;
        Person a=   creater.getPerson();

        PersonCreater2 creater2 =Person::new;
        Person b = creater2.getPerson("haha",20);
    }
}

interface PersonCreater{
    Person getPerson();
}
interface PersonCreater2{
    Person getPerson(String name,int age);
}