学习Scala：Map初始化过程详解及隐式类型转换

最新推荐文章于 2024-07-08 11:19:14 发布

昨夜星辰_zhangjg

最新推荐文章于 2024-07-08 11:19:14 发布

阅读量1.6w

点赞数 1

分类专栏： scala 文章标签： scala Map -方法 Map初始化隐式转换

本文链接：https://blog.csdn.net/zhangjg_blog/article/details/23845503

版权

scala 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

在Scala中，可以这样初始化一个Map对象：

var capital = Map("US" -> "Washington", "France" -> "Paris")

这种创建Map对象的方式，给人一种优雅的感觉，不得不佩服Scala语言作者的想象力。但是这种初始化的方式是如何实现的呢？ ->是一个操作符吗？还是一个方法？如果是一个方法的话， String对象上并没有这个方法， Object对象上也没有这个方法，那么字符串"US"是如何调用这个->方法的呢？

带着这些问题，我们写一个实例验证一下这种初始化是如何实现的。示例代码如下：

object Main {
	def main(args : Array[String]){
	  var capital = Map("US" -> "Washington", "France" -> "Paris")
	}
}

入口函数中只有一句代码，这句代码以上述的方式创建一个Map对象。在之前的博客中，我们讲述过，以object关键字修饰的是单例对象，这个单例对象编译成class文件之后，会有一个虚构类。虚构类的名字为Main$.class 。虚构类中有一个同名的成员方法main 。 Scala入口函数的主要逻辑都在这个main方法中。关于单例对象的实现方式，前面有几篇文章已经介绍过了，这里不再赘述。不清楚的读者可以参考前面的几篇博客：

学习Scala：从HelloWorld开始

学习Scala：孤立对象的实现原理

学习Scala：伴生对象的实现原理

我们知道，创建map对象的逻辑被编译在了Main$.class的main实例方法中。下面我们反编译Main$.class，看看到底是如何实现的。下面给出Main$.class中的main方法反编译之后的字节码：

 public void main(java.lang.String[]);
    flags: ACC_PUBLIC
    Code:
      stack=8, locals=3, args_size=2
         0: getstatic     #19                 // Field scala/Predef$.MODULE$:Lscala/Predef$;
         3: invokevirtual #23                 // Method scala/Predef$.Map:()Lscala/collection/immutable/Map$;
         6: getstatic     #19                 // Field scala/Predef$.MODULE$:Lscala/Predef$;
         9: iconst_2
        10: anewarray     #25                 // class scala/Tuple2
        13: dup
        14: iconst_0
        15: getstatic     #30                 // Field scala/Predef$ArrowAssoc$.MODULE$:Lscala/Predef$ArrowAssoc$;
        18: getstatic     #19                 // Field scala/Predef$.MODULE$:Lscala/Predef$;
        21: ldc           #32                 // String US
        23: invokevirtual #36                 // Method scala/Predef$.any2ArrowAssoc:(Ljava/lang/Object;)Ljava/lang/Object;
        26: ldc           #38                 // String Washington
        28: invokevirtual #42                 // Method scala/Predef$ArrowAssoc$.$minus$greater$extension:(Ljava/lang/Object;Ljava/lang/Object;)Lscala/Tuple2;
        31: aastore
        32: dup
        33: iconst_1
        34: getstatic     #30                 // Field scala/Predef$ArrowAssoc$.MODULE$:Lscala/Predef$ArrowAssoc$;
        37: getstatic     #19                 // Field scala/Predef$.MODULE$:Lscala/Predef$;
        40: ldc           #44                 // String France
        42: invokevirtual #36                 // Method scala/Predef$.any2ArrowAssoc:(Ljava/lang/Object;)Ljava/lang/Object;
        45: ldc           #46                 // String Paris
        47: invokevirtual #42                 // Method scala/Predef$ArrowAssoc$.$minus$greater$extension:(Ljava/lang/Object;Ljava/lang/Object;)Lscala/Tuple2;
        50: aastore
        51: checkcast     #48                 // class "[Ljava/lang/Object;"
        54: invokevirtual #52                 // Method scala/Predef$.wrapRefArray:([Ljava/lang/Object;)Lscala/collection/mutable/WrappedArray;
        57: invokevirtual #58                 // Method scala/collection/immutable/Map$.apply:(Lscala/collection/Seq;)Lscala/collection/GenMap;
        60: checkcast     #60                 // class scala/collection/immutable/Map
        63: astore_2
        64: return
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
               0      65     0  this   LMain$;
               0      65     1  args   [Ljava/lang/String;
              64       0     2 capital   Lscala/collection/immutable/Map;
      LineNumberTable:
        line 11: 0

在Scala源码中，一句创建Map对象的代码竟然对应class文件中的29条字节码。这真实太神奇了，编译器给我们做了大量的工作，简化了我们的编码任务，但是提高了学习门槛，我们必须明白编译器额外为我们做了哪些工作，才能对Scala理解的比较深入。就像《Scala编程》一书的作者再书中说的那样：一边情况下你不必知道编译器做了什么，但是有时候掀开盖子看看下面有什么，能加深我们的理解（大概意思是这样，原话不记得了）。

下面我们就分析main方法中的字节码，看看到底是怎样创建Map对象的。

前两条字节码指令（索引为0和3）的意思是调用Predef$中的Map方法，该方法的返回值为scala/collection/immutable/Map，也就是说这个方法会创建一个Map对象。这里要说一句， Predef也是一个单例对象，所以编译之后肯定有一个虚构类Predef$ 。

索引为9和10 的两条字节码指令的意思是创建一个长度为2的，类型为scala/Tuple2的数组。

索引为21的ldc指令，访问常量池中的字符串“US” ，根据这个常量池字符串，创建字符串对象。

索引为23的invokevirtual指令调用Predef$中的any2ArrowAssoc 方法，这个方法的参数是java/lang/Object，返回值也是一个java/lang/Object 。看到这里我们就感到奇怪了，为什么会调用这个方法呢？下面我们查看Predef的源码，看看这个方法是如何实现的。相关源码如下：

  final class ArrowAssoc[A](val __leftOfArrow: A) extends AnyVal {
    // `__leftOfArrow` must be a public val to allow inlining. The val
    // used to be called `x`, but now goes by `__leftOfArrow`, as that
    // reduces the chances of a user's writing `foo.__leftOfArrow` and
    // being confused why they get an ambiguous implicit conversion
    // error. (`foo.x` used to produce this error since both
    // any2Ensuring and any2ArrowAssoc pimped an `x` onto everything)
    @deprecated("Use `__leftOfArrow` instead", "2.10.0")
    def x = __leftOfArrow

    @inline def -> [B](y: B): Tuple2[A, B] = Tuple2(__leftOfArrow, y)
    def 鈫抂B](y: B): Tuple2[A, B] = ->(y)
  }
  @inline implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A] = new ArrowAssoc(x)

可以看出，这个any2ArrowAssoc 方法将传入的对象x包装成一个ArrowAssoc对象，这个对象是Predef的内部类，从上面的代码中可以看到，这个类中有一个叫做 ->的方法。这个方法根据传入的参数创建一个二元元组Tuple2 。

所以第23行的字节码指令的意义是：将字符串对象“US”装换成一个ArrowAssoc对象。

索引为26的ldc指令创建一个字符串对象“Washington” 。

索引为28的invokevirtual指令调用上面创建的ArrowAssoc对象的$minus$greater$extension方法。但是我们在源码中并没有看到这个方法，但是从名字上可以猜测出， minus代表减号- , greater代表大于号> ，所以加起来就是->方法，所以猜测这里就是调用的ArrowAssoc中的->方法。这个方法的调用者是由“US”包装成的ArrowAssoc对象（索引为23的指令创建的），参数是索引为26的指令创建的字符串对象“Washington” 。所以到此为止，根据“US”和“Washington”创建了一个二元元组Tuple2 对象。

索引为31的aastore指令将上面创建的Tuple2 对象放入索引为10的字节码指令创建的Tuple2 数组中。

从索引32到索引50的字节码指令重复13到31的字节码指令，根据“France”和“Paris”创建一个Tuple2对象，并放入之前创建的Tuple2 数组中。

索引为54的invokevirtual指令调用Predef$中的wrapRefArray方法，将上面创建的Tuple2 数组对象包转成一个scala/collection/mutable/WrappedArray对象。

索引为57的invokevirtual指令调用上面创建的scala/collection/immutable/Map对象（由索引为3的字节码指令创建）的apply方法，将上面的二元组Tuple2数组，存放到这个scala/collection/immutable/Map对象中，就完成了Map中数据的存储。这个apply方法定义在scala/collection/immutable/Map的父类GenMapFactory中，定义如下：

def apply[A, B](elems: (A, B)*): CC[A, B] = (newBuilder[A, B] ++= elems).result

到此为止， Map对象就创建完了，并且也把数据存到了Map对象中。

索引为63的astore_2指令将上面创建的Map对象保存到局部变量表中。

这个过程用Java表示的话，是这样的（只是为了说明原理，并不符合Java语法）：

Map map = Predef$.MODULE$.Map();

Tuple2[] tArray = new Tuple2[2] ;

ArrowAssoc arrowAssoc1 = Predef$.MODULE$.any2ArrowAssoc("US");
Tuple t1 = arrowAssoc1.->("Washington");
tArray[0] = t1;

ArrowAssoc arrowAssoc2 = Predef$.MODULE$.any2ArrowAssoc("France");
Tuple t2 = arrowAssoc2.->("Paris");
tArray[1] = t2;

map.apply(tArray);

由此可见， Scalac编译器为我们做了大量工作。其中有一个地方要重点强调。那就是默认将字符串对象转成 ArrowAssoc对象，并调用->方法。这是Scala中为了简化语法而引入的一个特性，叫做隐式类型转换。