Java8-lambda表达式

借助一段代码进行lambda表达式的分析：

public class Main {
    public static void main(String[] args) {
        MathOper addOper=new MathOper() {
            @Override
            public int oper(int a, int b) {
                return a+b;
            }
        };
        MathOper subOper=new MathOper() {
            @Override
            public int oper(int a, int b) {
                return a-b;
            }
        };
        oper(3,4,addOper);
        oper(3,4,subOper);
    }
    static void oper(int a,int b,MathOper mathOper){
        System.out.println(mathOper.oper(a,b));
    }
}
interface MathOper{
    int oper(int a,int b);
}

上面的代码代码中，MathOper是一个很简单的接口，里面只包含了一个抽象方法，为了方便起见，我没有创建它的实现类，而是在使用的时候，直接利用MathOper接口创建响应的匿名类对象，并在匿名类中实现oper方法，然后在static void oper方法中调用相应的匿名类对象去进行相应的计算，上面的操作方法虽然可以实现相应的功能，但是代码结构不是那么紧凑，是不是还可以更简单一点，有的：

public class Main {
    public static void main(String[] args) {
        MathOper addOper = (a, b) -> a + b;
        MathOper subOper = (a, b) -> a - b;
        oper(3, 4, addOper);
        oper(3, 4, subOper);
    }
    static void oper(int a, int b, MathOper mathOper) {
        System.out.println(mathOper.oper(a, b));
    }
}

interface MathOper {
    int oper(int a, int b);
}

 上面的代码中，我没有创建匿名类对象，只是将抽象函数的”操作结构“负值给了addOper,subOper变量，然后再在static void oper方法使用这些变量，上面的代码结构能不能再进一步优化呢？既然static void oper方法中已经有了mathOper变量声明，我们能不能把addOper,

subOper变量也一并省了，直接传递”操作结构“呢？答案是可以的，如下：

public class Main {
    public static void main(String[] args) {
        oper(3, 4, (a, b) -> a + b);
        oper(3, 4, (a, b) -> a - b);        
    }
    static void oper(int a, int b, MathOper mathOper) {
        System.out.println(mathOper.oper(a, b));
    }
}

interface MathOper {
    int oper(int a, int b);
}

 上面的代码更加紧凑了，没有声明多余的变量，直接将函数体传递给了oper方法，由oper方法去解析执行相应的操作，上面的这种紧凑的语法表达形式就是Lambda表达式，Lambda表达式的语法结构组成有：

1、由括号（”()“）包裹起来的并且被分号（","）隔开的参数，如上面的(a, b)

2、水平右指的箭头("->")

3、代码体，可由大括号("{}")包裹起来的代码块，也就是具体的功能实现语句，如果是简单的一条执行语句，则不需要由大括号包裹，如上面的a+b,再举一个对数组对象进行排序的例子，如下：

public class Main {
    public static void main(String[] args) {
        Person[] pers={new Person(12,"h1"),
                new Person(23,"h2"),
                new Person(14,"h3"),
                new Person(2,"h4")};
        Arrays.sort(pers,(b1,b2)->{
            return b1.getAge()-b2.getAge();
        });
        Arrays.stream(pers).forEach(obj->System.out.print(obj+" "));
    }
}
@Data
@ToString
class Person{
    int age;
    String name;
    public Person(int age,String name){
        this.age=age;
        this.name=name;
    }
}

上面的Arrays.sort函数的参数有两个：T[] a, Comparator<? super T> c；其中Comparator接口有一个注解：@FunctionalInterface，这个注解表明该接口是一个函数型接口，函数型的接口只能有一个抽象函数，该抽象接口的实现可用lambda表达式进行表示；但是进入Comparator接口可以发现，其方法并非只有一个，但是其他方法有一个特点，就是被default关键字修饰了，这里引出Java8的另一个新特性：Default Method

默认方法是接口中定义的一个具有方法实现体的方法，我们知道，接口中的抽象方法必须被其实现类进行重写，但是接口中的默认方法可由实现类直接继承，然后由其实现对象直接拿来用；如下图所示：

public class Main {
    public static void main(String[] args) {
        MathOper mathOper=new TribleMathOper();
        //实现类对象直接调用默认方法
        System.out.println(mathOper.myDefault(23));
        //lambda方法实现抽象方法的实现体
        MathOper lambdaOper=(a,b)->a*b;
        System.out.println(lambdaOper.oper(2,4));
    }
}
@FunctionalInterface
interface MathOper {
    int oper(int a, int b);
    default int myDefault(int a){
        return 2*a;
    }
}
class TribleMathOper implements MathOper{
    @Override
    public int oper(int a, int b) {
        return a+b;
    }
}

上面的实现类对象可以直接调用继承过来的默认方法，有了默认方法的功能，接口越来越像抽象类了

以上是lambda表达式使用总结，道阻且长，未来可期......