Java8揭秘(二)Java 8中的 Lambda表达式

第一章:Java 8中的 Lambda表达式

在这一章,我们说一说Lambda表达式的语法。我们将从经典的Java语法过渡到新式的Lambda表达式语法。

我们也会讲一讲Lambda表达式的原理-即在运行时Lambda表达式如何表示,涉及哪些字节码指令。

入门

如果你熟悉Groovy或者Ruby这些支持Lambda表达式的编程语言,那么你一开始可能会认为Java的Lambda表达式并不像其他编程语言中的那样简洁。在java中,Lambda表达式是SAM类型,SAM类型是一个具有单一抽象方法的接口。(对了,Java8接口可以包含非抽象方法了-即default/defender方法,我们将在后面讲到它)

举个例子,众所周知的Runnable接口就是SAM类型的:

Runnable r =()->System.out.println("hello Lambda!");

Comparator 接口也算一个:

Comparator cmp=(x, y)->(x < y)?-1:((x > y)?1:0);

像下面这样写也可以:

Comparator cmp= (x, y)->{
 return (x < y) ? -1: ((x > y)?1:0);
};

如此看来上面单行的Lambda表达式中隐含有return关键词。

       我来用下面的例子提示一下,使用Java8之前的语法,如何实现同样的比较器代码:

Comparator cmp=newComparator(){

  @Override

    publicint compare(Integer x,Integer y){

return (x< y)? –1:((x> y)?1:0);

    }

};

如你所见,在这两个例子中有相当一部分代码是相同的,相同部分正是Comparator 的比较逻辑:

(x< y)? –1:((x> y)?1:0)

当把经典风格java语法转变为Lambda表达式语法时,我们主要关注接口方法的参数和功能逻辑。

看另外一个例子。如果我打算写一个方法,此方法接收一个Lambda表达式作为参数,那么该怎么写?嗯…你得把方法参数声明成函数接口,然后才能传递Lambda表达式进来,如下所示:

Interface Action{

void run(Stringparam);

}

 

public void execute(Action action){

action.run(“Hello!”);

}

如果我们想要调用execute(..)方法,那么通常地做法,给execute方法传递一个Action的匿名实现类。如下所示:

execute(new Action{
 publicvoid run(String param){
 System.out.println(param);
 }
});

但是因为我们现在有函数接口做参数类型,所以我们可以用下面的方式调用execute(..):

execute((Stringparam)->System.out.println(param));

实际上,可以不需要声明Lambda表达式的参数类型:

execute(param->System.out.println(param));

一般来说,Lambda表达式的类型声明规则如下:要么为所有参数声明类型,要么去掉所有参数的类型声明。

既然这个Lambda表达式仅调用一个方法,且(该方法和函数接口中定义的方法)使用相同的参数,那么可以用方法引用(method reference)替代这个Lambda表达式。如下所示:

execute(System.out::println);

但是,如果(调用的方法)使用参数形式有变,就不能使用方法引用了,得使用完整的Lambda表达式,如下面这种情况:

execute(s->System.out.println(“*”+ s +“*”));

尽管Java本质上并没有函数类型(的变量),但是上面展示的语法已经相当不错,对于在java语言中应用Lambda表达式来说,我们也算有一个非常优雅的解决方案了。

函数接口

如刚才讲的,Lambda表达式在运行期表示为一个函数接口(functionalinterface)(或者说一个SAM类型),函数接口是一种只定义了一个抽象方法的接口。尽管JDK已经有一些接口都符合函数接口定义,比如Runnable 和 Comparator,但是这对API演进来说是显然不够的。我们又不能到处在代码里使用像Runnable这样的接口,因为这么做不合乎逻辑。

JDK8中新增了一个包,java.util.function,这个包里有一些专门给新增的API使用的函数接口。此处就不列出所有的函数接口了,有兴趣可以自行学习下java.util.function:)

下面列出几个java.util.function中定义的接口,都非常有趣:

  •   Consumer<T> – 在T上执行一个操作,无返回结果
  •   Supplier<T> –无输入参数,返回T的实例
  •   Predicate<T> –输入参数为T的实例,返回boolean值
  •   Function<T,R> –输入参数为T的实例,返回R的实例

java.util.function 中新定义了超过40个函数接口。通常可以从接口的名字看出其含义。举个例子,BiFunction和上面提到的Function接口非常相似,只是唯一不同点是BiFunction有两个输入参数而Function有一个。

我们可以从那些新接口中看到另一个常见模式,该模式是在一个接口继承另一个接口的时候,把多个参数声明成同一种类型。例如,BinaryOperator 继承BiFunction,目的仅仅是为了把两个输入参数声明为同类型,如下所示:

@FunctionalInterface public interface BinaryOperator extends BiFunction<T,T,T>{}

为了强调接口是函数接口,可以使用新注释@FunctionalInterface,来防止你的团队成员往这个接口里增加方法。这个注释除了在运行时使用,还给javac用来验证该接口是否真是函数接口,其内部的抽象方法是否不多于一个。

下面代码不能正常编译:

@FunctionalInterface interface Action{
void run(String param);
void stop(String param);
}

编译器抛出错误:

java: Unexpected @FunctionalInterface annotation
    Action is not a functional interface
    multiple non-overriding abstract methods found in interface Action

而下面的会编译通过

@FunctionalInterface interface Action {
void run(String param);
default void stop(String param){}

}

获取变量

如果Lambda表达式需要访问非静态变量或定义在其外部的对象,那么我们会碰到一种情况,就是Lambda表达式需要获取非体内变量,此时我们称之为一种“获取态”的Lambda表达式。

思考下面比较器的例子:

int minus_one =-1;
int one =1;
int zero =0;
Comparator cmp =(x, y)->(x < y)? minus_one :((x > y)? one : zero);

为了使Lambda表达式生效,Lambda表达式获取的变量minus_one、one和 zero必须是“实质的常量”。这意味着这些变量要么应该声明成final类型,要么不能二次赋值。

返回值是Lambda表达式

虽然在上面讲到的例子中,函数接口可以用作其他某个方法的参数,然而函数接口的用法并不限于当参数,函数接口还可以用作方法的返回值。也就是说我们可以从方法返回一个Lambda表达式,如下例子:

public class Comparator Factory{
    public Comparator makeComparator(){
        return Integer::compareUnsigned;
    }   
}

上面的例子展示了一段有效的方法代码,这个方法返回了一个方法引用。然而实际上仅像那样是不能从方法中返回一个方法引用的,其实编译器还会使用invokedynamic 字节码指令,生成一些代码来使它成为一个方法调用,该方法调用返回一个Comparator接口的实例对象。因此客户端代码只认为自己是在使用一个接口:

Comparator cmp=new ComparatorFactory().makeComparator();
cmp.compare(10, -5);// -1

序列化Lambda表达式

前一部分中使用的那段代码,创建了一个Comparator 实例对象,该实例对象可以让客户端代码使用。所有工作看似相当成功。但是,有个严重的问题,即是如果我们尝试序列化那个Comparator实例对象,代码就会抛出NotSerializableException异常。

因为序列化可能存在安全隐患,所以默认情况下,Lambda表达式不能序列化。为了能序列化,java8引入了所谓的类型关联(TypeIntersection),如下所示:

public class ComparatorFactory{
    public Comparator makeComparator(){
        return(Comparator&Serializable)Integer::compareUnsigned;
    }
}

Serializable接口一般认为是标记性的接口,该接口中没有声明任何方法,因此Serializable接口也可以称作ZAM类型(ZAM即Zero Abstract Methods)。

使用类型关联的一般规则如下:

SAM & ZAM1 & ZAM2 & ZAM3

也就是说,如果返回结果是SAM类型的,那么我们可以用SAM类型和一个甚至多个ZAM类型“相关联”。我们现在事实上认为作为返回结果的Comparator 实例对象也是Serializable类型的。

经过上面对返回结果强制转换类型后,编译器在编译后的class文件中多生成了一个方法,如下所示:

private  static  java.lang.Object  $deserializeLambda$(java.lang.invoke.SerializedLambda);

此外,通过使用invokedynamic 字节码指令策略,当通过makeComparator()方法 创建一个Comparator 的实例对象的时候,编译器就会调用$deserializeLambda$(..) 方法。 

反编译Lambda表达式

现在给大家讲一讲这背后的实现原理。当我们在代码中使用Lambda表达式的时候,同时也了解下代码实际上是怎么编译的,这会很有趣。

目前(像Java 7之前的版本),如果你想在java中模仿Lambda表达式,那么你得定义一个匿名内部类。这样会在编译后生成一个相应的class文件。如果你在代码中定义多个匿名内部类,那么这些匿名类只不过是在其相应的class文件名字中增加一个数字后缀。Lambda表达式编译后会是怎样呢?

仔细思考下面的代码:

public class Main { 
  @FunctionalInterface  interface Action{
void run(String s);

    }  

public  void  action(Action action){

    action.run("Hello!");

       

public  static  void main(String[] args){

    new  Main().action((String s)->System.out.print("*"+ s +"*"));

    } 

}

编译后产生两个类文件:Main.class和Main$Action.class,但并没有生成带编号的类,带编号的类通常在匿名类编译后产生。这样在Main.class中一定有什么东西,实现了我们在main方法中定义的Lambda表达式。(我们反编译下Main.class看看究竟)

$ javap -p Main
 
Warning: Binary file Main contains com.zt.Main
Compiled from "Main.java"
public class com.zt.Main {
  public com.zt.Main();
  public void action(com.zt.Main$Action);
  public static void main(java.lang.String[]);
  private static java.lang.Object Lambda$0(java.lang.String);

}

哈!在编译后的class中生成了一个方法Lambda$0! -C- V选项会给我们展示实际的字节码和常量池定义。

下面的main方法揭示了invokedynamic指令用来分派方法调用。

public static void main(java.lang.String[]);
   Code:
   0: new          #4   // class com/zt/Main
   3: dup
   4: invokespecial#5    // Method "":()V
    7: invokedynamic #6,  0  // InvokeDynamic #0:run:()Lcom/zt/Main$Action;
   12: invokevirtual  #7      // Method action:(Lcom/zt/Main$Action;)V
   15: return

可以在常量池中找到引导方法,该引导方法负责在运行时把所有内容链接起来:

BootstrapMethods:
  0: #40 invokestatic java/lang/invoke/LambdaMetafactory.metaFactory:(    \
Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;             \
Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;          \
Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)         \
Ljava/lang/invoke/CallSite;
  Method arguments:
    #41 invokeinterface com/zt/Main$Action.run:(Ljava/lang/String;)Ljava/lang/Object;
    #42 invokestatic com/zt/Main.Lambda$0:(Ljava/lang/String;)Ljava/lang/Object;
    #43 (Ljava/lang/String;)Ljava/lang/Object;

你可以看见到处都有MethodHandle的影子,但我们现在不会深入去讲MethodHandle。到现在,我们可以确认上面说的那个定义恰恰指的是生成的方法Lambda$0。

如果我定义一个名字是Lambda$0的静态方法会这么样?Lambda$0毕竟算一个有效标识符!于是,我定义了Lambda$0方法,如下所示:

Public static void Lambda$0(String s){

    return null;

}

结果编译失败,不允许我在代码中定义Lambda$0方法。

java: the symbol Lambda$0(java.lang.String) conflicts with a

        compiler-synthesized symbol in com.zt.Main

这实际上告诉我们在编译过程中,在Main类里构建其他方法前就先构建的Lambda表达式。

总结

在此为本文的第一章做一个小结。我敢肯定,Lambda表达式在不久的将来会对Java产生巨大的影响。又因为Lambda表达式语法结构相当不错,所以一旦开发者认识到像Lambda这些特性有益于提升开发效率,那么我们将会看到Lambda表达式更广泛的应用。

 

    原文作者:诸相非相
    原文地址: https://blog.csdn.net/wwwsssaaaddd/article/details/24212693
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞