Java 8的烹调方式– Lambda项目

什么是project lambda ：Project lambda是用于以Java语言语法启用lambda表达式的项目。 Lambda表达式是功能编程语言（如lisp）中的主要语法。 Groovy将是支持lambda表达式（也称为闭包）的java的最接近亲戚。

那么什么是lambda表达式？ 它是一块代码块，可以像分配任何其他数据一样，将其分配给变量或作为参数传递给方法，或作为参数传递给另一个lambda表达式。 该代码也可以在需要时被调用。 在Java中支持此功能的主要动机是，在使用某些需要API用户提供一些代码的API时，删除了许多样板代码，但由于Java的语法要求，最终使用了内部类。 最常见的此类API是Java线程API，我们需要能够告诉该API在新线程中执行哪些代码，但最终实现Runnable。

该规范仍在开发中，并且正在不断变化。 本文只是给出了一个关于期望的想法。

功能接口 ：Java规范开发人员几乎从未希望修改JVM规范，这种情况也不例外。 因此，他们以某种方式制定规范，以便可以在不对JVM进行任何修改的情况下实现lambda。 因此，您可以使用源版本1.8和目标版本1.5轻松编译类。

因此，lambda代码将保留在匿名类的实现中，该类实现的接口只有一个方法。 很好，不完全是，该接口可以有多个方法，但是它必须可由仅定义一个方法的类实现。 我们将这种接口称为功能接口。 以下是功能接口的一些示例。

//A simple case, only one method
//This is a functional interface
public interface Test1{
    public void doSomething(int x);
}

//Defines two methods, but toString() is already there in
//any object by virtue of being subclass of java.lang.Object
//This is a functional interface
public interface Test2{
    public void doSomething(int x);
    public String toString();
}

//The method in Test3 is override compatible with 
//the method in Test1, so the interface is still 
//functional
public interface Test3 extends Test1{
    public void doSomething(int x);
}

//Not functional, the implementation must 
//explicitly implement two methods.
public interface Test4 extends Test1{ 
    public void doSomething(long x);
}

Lambda表达式 ：在Java 8中，lambda表达式只是使用匿名类实现功能接口的不同语法。 语法的确比创建匿名类的语法简单得多。 语法主要是这种形式：

argumentsList->正文

argumentsList就像java方法参数列表一样-用逗号分隔并括在括号中，但有一个例外-如果只有一个参数，则括号是可选的。 也可以选择提及参数的类型。 如果未指定类型，则将推断它们。 主体可以有两种类型-表达式主体和代码块主体。 表达式主体只是返回值的有效Java表达式。 就像方法主体一样，代码块主体包含一个代码块。 代码块主体具有与方法主体相同的语法，包括必需的大括号。

以下示例显示了如何使用lambda语法实现新线程。

//The thread will keep printing "Hello"
new Thread(() -> { while(true){ System.out.println("Hello"); }}).start();

下面的示例显示了表达式语法

public interface RandomLongs{
    public long randomLong();
}

RandomLongs randomLongs = () -> ((long)(Math.random()*Long.MAX_VALUE));
System.out.println(randomLongs.randomLong());

泛型和lambda ：但是，如果我们想使用lambda实现泛型方法，该怎么办？ 规范开发人员提出了一种不错的语法，即在类型参数之前声明类型参数。 下面显示了一个示例–

public interface NCopies{
    public <T extends Cloneable> List<T> getCopies(T seed, int num);
}

//Inferred types for arguments also supported for generic methods
NCopies nCopies = <T extends Cloneable> (seed, num) -> { 
                    List<T> list = new ArrayList<>(); 
                    for(int i=0; i<num; i++) 
                        list.add(seed.clone()); 
                    return list;
                };

需要注意的一点 ：lambda表达式实现的实际接口和方法取决于使用它的上下文。 可以通过存在赋值操作或通过在方法调用中传递参数来设置上下文。 没有上下文，lambda毫无意义，因此直接在lambda表达式上直接调用方法是不正确的。 例如，以下内容将给出编译错误–

public interface NCopies{
    public <T extends Cloneable> List<T> getCopies(T seed, int num);
}

//This code will give a compilation error,
//As the lambda is meaningless without a context
(<T extends Cloneable> (seed, num) -> { 
                    List<T> list = new ArrayList<>(); 
                    for(int i=0; i<num; i++) 
                        list.add(seed.clone()); 
                    return list;
                }).getCopies(new CloneableClass(), 5);


However, the following would be perfectly alright, because there is an assignment context for the lambda. 

NCopies nCopies = <T extends Cloneable> (seed, num) -> { 
                    List<T> list = new ArrayList<>(); 
                    for(int i=0; i<num; i++) 
                        list.add(seed.clone()); 
                    return list;
                };
                
nCopies.getCopies(new CloneableClass(), 5);

精简的lambda ：Lisp对lambda的支持比这要灵活得多。 整个lisp语言都基于lambda。 但是，java必须限制语法使其适合自己的语法。 此外，lisp是一种解释型语言，具有在所有信息可用时在运行时执行操作的优势。 Java是一种编译语言，它必须遵守更为严格的类型和控制流等规则，以免在运行时产生意外。 考虑到这一点，在Java 8中精简的lambda看起来并不那么糟糕。

参考： Java 8中的烹饪方法–来自JCG合作伙伴的 Lambda项目   极客文章博客上的Debasish Ray Chawdhuri。

翻译自: https://www.javacodegeeks.com/2012/02/whats-cooking-in-java-8-project-lambda.html