java8-Lambda

1概述

Lambda 表达式的Java 实现：第一个是Lambda的自身，第二个是函数式接口。
Lambda 表现形式可以理解成一个匿名类。

Lambda表达式可以理解为一种匿名函数:它没有名称，但有参数列表、函数主体、返回
类型，可能还有一个可以抛出的异常的列表。
Lambda表达式让你可以简洁地传递代码。
函数式接口就是仅仅声明了一个抽象方法的接口。
只有在接受函数式接口的地方才可以使用Lambda表达式。
Lambda表达式允许你直接内联，为函数式接口的抽象方法提供实现，并且将整个表达式
作为函数式接口的一个实例。

Lambda表达式不是独立执行的，而是构成了一个函数式接口定义的抽象方法的实现，该函数式接口定义了它的目标类型。结果，只有在定义了lambda表达式的目标类型的上下文中，才能使用该表达式。当把一个lambda表达式赋给一个函数式接口的引用时，就创建了这样的上下文。

当目标类型上下文中出现lambda表达式时，就会自动创建实现了函数式接口的一个类的实例(类似于匿名类)，函数式接口声明的抽象方法的行为由lambda表达式定义。当通过目标调用该方法时，就会执行lambda表达式。

为了在目标类型上下文中使用lambda表达式，抽象方法的类型和lambda表达式的类型必须兼容。eg:如果抽象方法指定了两个int类型的参数，那么lambda表达式也必须执行两个参数，其类型要么被显示指定为int类型，要么在上下文中可以被隐式的推断为int类型。总的来讲，lambda表达式的参数的类型和数量必须与函数式接口内的抽象方法的参数兼容；返回类型必须兼容；并且lambda表达式可能抛出的异常必须能被该方法接受。

2.其他相关

Lambda表达式是否只是一个匿名内部类的语法？

答案是NO。原因有两点：

• 性能影响: 假如lambda表达式是采用匿名内部类实现的，那么每一个lambda表达式都会在磁盘上生成一个 class文件。当JVM启动时，这些class文件会被加载进来，因为所有的class文件都需要在启动时加载并且在使用前确认，从而会导致JVM的启动变慢。
• 向后的扩展性: 如果Java8的设计者从一开始就采用匿名内部类的方式，那么这将限制lambda表达式未来的使发展范围。

匿名类与 lambda表达式的区别：

• 在匿名类中，this 指代的是匿名类本身；而在lambda表达式中，this指代的是lambda表达式所在的这个类。
• lambda表达式的类型是由上下文决定的，而匿名类中必须在创建实例的时候明确指定。
• Lambda 表达式的编译方法是：Java 编译器编译 Lambda 表达式并将他们转化为类里面的私有函数，它使用 invokedynamic 指令（ Java 7 ，即动态启用）动态绑定该方法。

3. 代码示例

本例以 策略模式 为例：

测试代码包目录结构.png

• 定义一个实体(Apple)，包含了颜色(color)和重量（weight）。

public class Apple {
    private String color;
    private Integer weight;

    public Apple(String color, Integer weight) {
        this.color = color;
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

策略接口

public interface AppleFormatter {

    String accept(Apple apple); // 接收一个 Apple

    default Apple print(Apple apple) {
        apple.setColor("afterChange Color");
        return apple;
    }
}

策略一： 显示重量

public class AppleFancyFormatter implements AppleFormatter {

    @Override
    public String accept(Apple apple) {
        String characteristic = apple.getWeight() > 150 ? "heavy" : "light";
        return "A " + characteristic + " " + apple.getColor() + " apple";
    }
}

策略二：显示颜色

public class AppleSimpleFormatter implements AppleFormatter {

    @Override
    public String accept(Apple apple) {
        return "An apple " + apple.getColor() + " .";
    }
}

策略调用

public class AppleMain {

    public static void main(String[] args) {
        List<Apple> list = Arrays.asList(new Apple("red", 150));

        //策略模式
        prettyPrintApple(list, new AppleSimpleFormatter()); //An apple red .

        //匿名类实现
        prettyPrintApple(list, new AppleSimpleFormatter() {
            public String accept(Apple apple) {
                return "匿名类:An apple " + apple.getWeight() + " .";
            }
        }); // 匿名类:An apple 150 .

        //匿名类重写
        printApple(list, new AppleFormatter() {

            @Override
            public String accept(Apple apple) {
                return null;
            }

            @Override
            public Apple print(Apple apple) {
                apple.setColor(" other print color");
                return apple;
            }
        }); // print :  other print color

        //表达式
        prettyPrintApple(list, (Apple apple) -> "lambda:An a " + apple.getWeight()); // lambda:An a 150


        //表达式重写测试
        printApple(list, (Apple apple) -> {
            apple.setColor("");
            return "";
        });//print : afterChange Color
    }

    /**
     * 打印
     */
    public static void prettyPrintApple(List<Apple> list, AppleFormatter appleFormatter) {
        for (Apple apple : list) {
            String output = appleFormatter.accept(apple);
            System.out.println(output);
        }
    }

    public static void printApple(List<Apple> list, AppleFormatter appleFormatter) {
        for (Apple apple : list) {
            Apple printApple = appleFormatter.print(apple);
            System.out.println("print : " + printApple.getColor());
        }
    }
}

写在后面

• 关于策略模式
  行为参数化是函数编程的核心思想，在初看Lambda 时候就感觉和策略模式很像，如在调用类中的 第一个调用，通过传入的实现类不同，得到不同的策略结构。

• 关于 匿名函数实现策略
  使用第一种方式虽然看起来比较灵活，但是每个策略都需要新建一个实现类未免太过繁琐。所以后面就想到了使用匿名类来实现，这样一眼看起来只需要在一个接口中定义好需要的方法，后续直接在匿名类中实现该方法即可，但是又会有一个新的问题：匿名类的内部 this 指向问题，而且代码看起来也非常的难看。

• 关于 Lambda
  使用Lambda 可以避免了声明一个内部类的操作（new Class())，同时如上（2.其他相关）所述，效率也会有提升。此时，我又考虑Lambda 是如何动态绑定在函数接口中的，实践方式如下：我在函数接口中增加了一个方法，结果在调用方法中出现了编译异常 multiple non-overriding abstract methods found in interface Action。
  至此就又引出了另一个知识点：@FunctionalInterface ，看看这个注解的说明：

1、 该注解只能标记在”有且仅有一个抽象方法”的接口上。
2 、JDK8接口中的静态方法和默认方法，都不算是抽象方法。
3 、接口默认继承Java.lang.Object，所以如果接口显示声明覆盖了Object中方法，那么也不算抽象方法。
4、 该注解不是必须的，如果一个接口符合”函数式接口”定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错。

我们可以这样理解：使用Lambda 后 编译器就会认为该类为 FunctionalInterface （虽然此时我们并未使用该注解），由于该类只有一个抽象接口方法，Lambda 就能找到要去实现哪个方法了。

---

以上为 阅读 java8实践 第一章后的笔记，坐等日后自己前来吐槽。