深入学习Java8 Lambda （default method, lambda, function reference, java.util.function 包）

Java 8 Lambda 、MethodReference、function包

多年前，学校讲述C#时，就已经知道有Lambda，也惊喜于它的方便，将函数式编程方式和面向对象式编程基于一身。此外在使用OGNL库时，也是知道它可以支持Lambda。但是OGNL中的lambda毕竟不是java语言本身支持，操作有诸多不便，使用Lambda不就是为了方便吗。但是Java中迟迟没有支持Lambda。直到Java 8的来临，总算给Java注入了这个新鲜血液。

1、default method or static method interface
- 1.1 default method
- 1.2 static method
2、Lambda
3、Method Reference
4、java.util.function包
5、综合demo
6、Lambda的翻译、运行、性能

1、default Method or static method in interface

1.1 default method

Java 8 之前，为一个已有的类库增加功能是非常困难的。具体的说，接口在发布之后就已经被定型，除非我们能够一次性更新所有该接口的实现，否则向接口添加方法就会破坏现有的接口实现。Default method的目标即是解决这个问题，使得接口在发布之后仍能被逐步演化。

Default method，即接口中声明的方法是有方法体的方法，并且需要使用default关键字来修饰。

举个例子：java.util.Collection是线性表数据结构的统一接口，java 8里为它加上4个方法: removeIf(Predicate p)、spliterator()、stream()、parallelStream()。如果没有default method，

就得对java.util.Collection、java.util.AbstractCollection、java.util.Set 等，还有很多用户自定义的集合添加这4个方法，如果不添加，这些代码在jdk8上运行就会失败。

而使用default method，就可以完美解决这个问题。只要在java.util.Collection中将这4个新加的方法设置为default即可。

在引入default方法后，可能会带来如下问题：

1)一个类ImplementClass直接实现（中间没有父类）了两个接口 InterfaceA, InterfaceB，这两个接口中有同一个方法： void hello()。那么ImplementClass必须重写方法hello，不然不知道到底继承哪个，这里不会去管接口中的default

2) 一个类ImplementClassA 直接实现了接口InterfaceA，InterfaceA中定义了一个非default的void hello()方法。有另外一个接口InterfaceB，定义了一个default方法void hello();现在有一个实现类ImplementClassAB，extends了ImplementClassA，implements了InterfaceB, 且ImplementClassAB没有重写void hello()方法。那么在调用ImplementClassAB#hello()时,到底是调用的是ImplementClassA#hello()，还是调用的是InterfaceB#hello()呢？

为了解决这个问题，有这么一项原则：类的方法优先调用。所以应该是调用ImplementClassA#hello()。

1.2 static method

与此同时，java8在接口中也引入了static method，它也是有方法体的，需要使用static关键字修饰。另外要特别注意的是：如果一个类中定义static方法，那么访问这个方法可以使用ClassName.staticMethodName、instance.staticMethodName两种方式来访问static方法，但是对于接口中定义的静态方法，只能通过InterfaceName.staticMethodName方式来访问。

2、Lambda

Lambda官方教程地址：

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

2.1 Lambda用在什么地方?

Anonymous Classes, shows you how to implement a base class without giving it a name.
Although this is often more concise than a named class, for classes with only one method, 
even an anonymous class seems a bit excessive and cumbersome. 
Lambda expressions let you express instances of single-method classes more compactly.

从这段话可以看出Lambda主要用于替代匿名类，并以简约而清晰的方式展现业务处理逻辑。

2.2 语法格式

将匿名类的写法转换成一行代码的格式：

(arguments) -> {method body}

2.3 demo

下面用一个例子来说明：

    public static interface Computer{
        public double compute(double a, int b);
    }

    public static void executeCompute(List<Integer> list, Computer computer){
        double result = 1D;
        if(list!=null){
            for (Integer i : list) {
                if(i==0){
                    continue;
                }
                result = computer.compute(result, i);
            }
        }
        System.out.println(result);
    }

我们可以在Computer的实现类中完成各种各样的操作，例如求和、乘积等。如果使用匿名类来实现的话，代码量会有不少，即便是我们代码写的很规范，变量名命名也可以做到见名知意，但是代码看起来仍旧是比较凌乱的：

    @Test
    public void test0(){
        Computer getSum = new Computer() {
            @Override
            public double compute(double a, int b) {
                if(b!=0) {
                    return a + b;
                }
                return a;
            }
        };
        executeCompute(nums, getSum);

        Computer getMult = new Computer() {
            @Override
            public double compute(double a, int b) {
                return a * b;
            }
        };
        executeCompute(nums, getMult);
    }

如果使用Lambda来编写的话，看起来就简明清晰了：

@Test
public void test0(){
    executeCompute(nums, (a,b)->{ return (b!=0) ? (a+b) : a;});
    executeCompute(nums, (a,b)->{ return a * b;} );
}

从上面的demo看出，我们甚至不需要去设置参数的类型，只需要一个参数列表即可。

如果要处理的参数是复杂类型怎么办呢？

    /**
     * Operate an Object use an Lambda
     */
    static class Person{
        private int age;
        private String name;
        Person(String name, int age){
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "name: "+name + " age: "+age;
        }

    }


    private static interface InfoGetter {
        public String get(Person p);
        public default String get2(int a, Person p){return "";};
        public default String get3(Person p){return "";};
    }

    static void show(List<Person> persons, InfoGetter infoGetter){
        persons.forEach((person)->{
            System.out.println(infoGetter.get(person));
        });
    }

测试代码：

    static List<Person> persons = new ArrayList<>();
    static{
        for(int i = 0 ; i< 10; i++) {
            persons.add(new Person("hello_"+i, i));
        }
    }

    @Test
    public void test1(){
        LambdaTests ctx = this;

        InfoGetter getter1= (Person person)->{
            System.out.println(ctx == this);
            Method[] methods = this.getClass().getMethods();
            return person.toString();
        };
}

2.4 Lambda几点注意事项(FunctionalInterface)

1、lambda用于替代匿名内部类的实例，它的本质是运行是由JVM产生匿名内部类，并生成一个实例。

2、一个接口（只能是接口），想要使用Lambda来替代，最多只能有一个抽象方法。

3、一个lambda通常用作某个方法的参数

4、lambda内部的this，是产生lambda时的对象。

5、lambda表达式的参数，可以有类型，也可以不指定。

2.5 Lambda 与匿名类的区别

1）一个是对象，一个是类。Lamdba表达式，可以看做是一个匿名类的实例。

2）this关键字含义不同。在匿名类中访问外部类的实例，需要使用outterclass.this来引用，而在lambda中可以直接使用this来引用。

2.6 Lambda 的单例与多例

上面知道lamdba是一个实例，那么我在一个方法内部，写上几个完全一样的lambda，他们是否是同一个对象呢？什么情况下，你写的lambda永远是同一个实例呢？

为了找到答案，改造测试用例如下：

    @Test
    public void test1(){
        LambdaTests ctx = this;

        InfoGetter getter1= (Person person)->{
            System.out.println(ctx == this);
            Method[] methods = this.getClass().getMethods();
            return person.toString();
        };

        InfoGetter getter2= (Person person)->{
            System.out.println(ctx == this);
            return person.toString();
        };

        show(persons, getter1);
        System.out.println(getter1==getter2);

        InfoGetter getter3 = getInfoGetter();
        InfoGetter getter4 = getInfoGetter();
        System.out.println(getter3==getter4);

        InfoGetter getter5 = getInfoGetter("a");
        InfoGetter getter6 = getInfoGetter("b");
        System.out.println(getter3==getter5);
        System.out.println(getter5==getter6);

        InfoGetter getter7 = getInfoGetter("a",1);
        InfoGetter getter8 = getInfoGetter("b",2);
        System.out.println(getter3==getter5);
        System.out.println(getter7==getter8);
    }

    static InfoGetter getInfoGetter(){
        return (p)->"";
    }

    static InfoGetter getInfoGetter(String str){
        System.out.println(str);
        return (p)->{int a = 1; return "" + a;};
    }
    static InfoGetter getInfoGetter(String str, int i){
        System.out.println(str);
        return (p)->str + i;
    }

调试截图：

从上面的几个测试用例上，可以得出如下结论：

1）每写一次lambda表达式，就代表创建一个实例（不管表达式里，会引用什么内容）。

2）想要得到一个单例的lambda实例，可以在static方法中声明该lambda，并且该lambda方法体中，除了lambda代表的方法的参数外，不能用其他的变量。

3、MethodReference

3.1 什么是MethodReference ？

Person p = new Person()；这行代码里，我们称p为对象的引用。那么什么是method 引用呢？故名思议，一个变量指向了一个方法，就称为方法引用。

官方文档：https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

java中的method分为static，非static的，构造器本身也是一个方法。要想引用到这些方法，该如何做呢？

kind	example
引用到一个static方法	`类::static方法` 例如：Math::abs
引用到一个对象的某个方法	`对象：：方法` 例如：System.out::print
引用到一个类的某个方法	`类：方法` 例如：PrintWriter::print
引用到一个构造函数	`类：new` 例如：String::new

3.2 何时可以使用MethodReference？

Lambda用于简化匿名类的写法。有时候，我们写的表达式中，只是调用了另外一个类的某个方法。此时我们连lamdba表达式都可以省略了，使用MethodReference来表示即可。

3.3 demo

/***
 * Lambda 的本质是在运行时（编译时不会产生的）产生一个匿名内部类
 * MethodReference 的本质是产生一个Lambda，并在lambda里调用你指定的方法。
 * 所以如果你要写的Lambda只是用于调用另外一个方法时，你完全可以用MethodReference来替代的。
 */
public class MethodReferenceTest {

    private static interface MyPrinter {
        public void print(Serializable o);
    }

    private static void printArray(Integer[] arr, MyPrinter printer){
        if(arr==null){
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            printer.print(arr[i]);
            printer.print(" ");
        }
        printer.print("\n");
    }

    @Test
    public void test0(){
        // 原始写法
        Integer[] arr1 = new Integer[]{12,23,545,2,345,0, -1};
        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer t1, Integer t2) {
                return t1.compareTo(t2);
            }
        };
        Arrays.sort(arr1, comparator1);
        printArray(arr1, new MyPrinter() {
            @Override
            public void print(Serializable o) {
                System.out.print(o);
            }
        });

        // 使用lambda的写法
        Integer[] arr2 = new Integer[]{12,23,545,2,345,0, -1};
        Arrays.sort(arr2, (Integer x, Integer y)->{return x.compareTo(y);});
        printArray(arr2, (x)->System.out.print(x));

        // 使用MethodReference的写法
        Comparator<Integer> comparator3 = Integer::compareTo;
        Integer[] arr3 = new Integer[]{12,23,545,2,345,0, -1};
        Arrays.sort(arr3, comparator3);
        MyPrinter printer = System.out::print;
        printArray(arr3, printer);

        printer.print("test finish\n");

        Comparator<Integer> comparator4 = (Integer x,Integer y)->{return x.compareTo(y);};

    }
}

上面的例子中，声明了一个接口MyPrinter，然后在printArray方法中使用该接口。那么此后在调用printArray方法时，就可以使用lambda了。当lambda的方法体只是调用某个方法是，可以直接使用method refence来替代，所以就可以直接使用System.out::print来执行。此外，Arrays.sort的第二个参数是一个Comparator接口，此时我们又可以使用lambda来实现一个Comparator了，在我们要实现的Comparator里，只需要调用comparTo方法，所以我们又可以使用Method reference来替代lambda了。

4、java.util.function包

通过上面的学习知道，只有接口才可能被lambda替代，抽象类是不行的。很多时候，要使用的接口里的方法，也就那一两个。如果每一次我们想要使用lambda时，都去声明一个接口岂不很麻烦吗？好在JDK里内置了可能常用的接口，在java.util.function包下。

来看看JDK doc里如何描述这个包的：

Functional interfaces (java.util.function包下的这些接口) provide target types (函数的参数，被称为target) for lambda expressions and method references. Each functional interface has a single abstract method, called the functional method for that functional interface, to which the lambda expression’s parameter and return types are matched or adapted. 这个意思再明白不过了。

　在学习这些接口之前，先要知道几个英文单词的含义：Nilary 零元，Unary 一元，Binary 二元，Ternary 三元，Quaternary 四元。对于一个算子来说，一个参数，就是一元运算；2个参数就是二元运算。

在java.util.function包下提供了很多接口（我们可以直接理解为函数），主要分为下面几类：

1）Predicate 为target type提供断言。参数 T，返回 boolean。

2）Consumer 消费target type。参数 T，无返回值（void）。

3）Function 对target type做转换。参数T，返回R。

4）Supplier 供应target，可以理解为target的factory。无参，返回T。

5）UnaryOperator 一元运算。继承Function接口。参数T，返回T。

6）BinaryOperator 二元运算。参数 T、U,返回R。

java.util.function下的接口最多支持到二元运算。有了这些接口，我们就可以省去创建接口的功夫，而直接使用lambda了。

如果自定义functional interface呢？其实很简单，定义一个可以用作lambda的接口，然后使用@FunctionalInterface 注解标注即可，当然这个注解并不是必须用的，只是使用了注解后，编译器会帮你检查一个FunctionInterface的必要条件。

5、综合Demo

下面就综合上面这些内容，用一个demo演示一下：

提供一个基础数据库表：

    private static class Person {
        String id;
        String name;
        int age;
        Gender gender;

        Person(String id, String name, int age, Gender gender){
            this.id = id;
            this.name = name;
            this.age = age;
            this.gender =gender;
        }

        @Override
        public String toString() {
            return "id: "+id+"\tname: "+name + "\tage: "+age+"\tgender: "+gender;
        }
    }

    enum Gender{
        man,woman
    }

    static Collection<Person> persons = new ArrayList<>();
    static{
        for (int i = 0; i < 100; i++) {
            persons.add(new Person("id_"+i, "name_"+i, i, i%3==0 ? Gender.woman : Gender.man));
        }
    }

筛选出满足条件的行：

    public static <Row> Collection<Row> doSelection(Collection<Row> table, Predicate<Row> rowWhere) {
        Predicate isNull = (c) -> c == null;
        if(isNull.test(table)){
            return Collections.EMPTY_LIST;
        }

        Collection<Row> result = new ArrayList<>();
        table.forEach(row -> {
            boolean rowAvailable = row !=null && (rowWhere !=null ? rowWhere.test(row) : true);
            if (rowAvailable) {
                result.add(row);
            }
        });
        return result;
    }

投映出满足条件的列：

    public static <Row, Column> Collection<Column> doProjection(Collection<Row> table, Predicate<Row> rowWhere, String columnName, BiFunction<Row, String, Column> columnGetter, Predicate<Column> columnPredicate) {
        Predicate isNull = (c) -> c == null;
        if(isNull.test(table)){
            return Collections.EMPTY_LIST;
        }

        Collection<Column> result = new ArrayList<>();
        table.forEach(row -> {
            boolean rowAvailable = row !=null && (rowWhere !=null ? rowWhere.test(row) : true);
            if (rowAvailable) {
                Column column = columnGetter.apply(row, columnName);
                boolean columnAvailable =column!=null && (columnPredicate!=null?columnPredicate.test(column) : true);
                if(columnAvailable) {
                    result.add(column);
                }
            }
        });
        return result;
    }

测试：

    @Test
    public void test0() {
        Collection<Person> selection = doSelection(persons, (person ->person.age>84 && person.gender==Gender.man));
        Consumer<Person> printer =System.out::println;
        selection.forEach(printer);
    }

    @Test
    public void test1() {
        Collection<String> projection = doProjection(persons,
                (Person person) -> {return person.age>84 && person.gender==Gender.man;},
                "name",
                (Person person, String filedName)->{return "name".equals(filedName) ? person.name : "";},
                null
                );
        Consumer<String> printer = System.out::println;
        projection.forEach(printer);
    }

结果：


id: id_85    name: name_85    age: 85    gender: man
id: id_86    name: name_86    age: 86    gender: man
id: id_88    name: name_88    age: 88    gender: man
id: id_89    name: name_89    age: 89    gender: man
id: id_91    name: name_91    age: 91    gender: man
id: id_92    name: name_92    age: 92    gender: man
id: id_94    name: name_94    age: 94    gender: man
id: id_95    name: name_95    age: 95    gender: man
id: id_97    name: name_97    age: 97    gender: man
id: id_98    name: name_98    age: 98    gender: man
name_85
name_86
name_88
name_89
name_91
name_92
name_94
name_95
name_97
name_98

Process finished with exit code 0

6、Lambda 翻译与运行、性能

Lambad到底是怎样翻译的，又是如何保证this执行的是创建lambda的那个上下问题的。翻译的工作整个程序运行性能有多大的影响？这些问题都将在后续文章补充。

如果来不及等待，可以先参考：http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html

本文链接：https://www.cnblogs.com/f1194361820/p/8276959.html