在这些情况下,Scala值类将被"装箱",对吧？

Question

如果我有这个值类:

class ActionId(val value: Int) extends AnyVal

那么,在下面的所有例子中,将为值类分配一个对象？(它将被"装箱" - 它不会简单地打开到一个普通的32位整数,对吧？)

1. 一个返回值类的函数 - 值类会转义范围,因此会被"装箱"？

   def someFunction(): ActionId = {
     ...
     return ActionId(123)
   }
   

2. 返回具有值类成员的对象的函数- 值类会转义范围,因此将"装箱"？

   case class Post(id: ActionId, ...) { ... }
   
   def someFunction(): Post = {
     ...
     val somePost = Post(ActionId(123), ...) // ActionId will be "boxed", right?
     return somePost
   }
   

3. 即使一个值类成员的对象是未在返回(并没有真正逃脱的范围),该值类仍然会"盒装",当它被用作另一个类的成员(作为一个字段Post级,在这个例子中)？

   def anotherFunction() {
     ...
     val somePost = Post(ActionId(123), ...) // "Boxed" here too, right?
   
     // ... do something with somePost
   
     // But don't:  return somePost
   
     // However some *other* similar functions *do* return `somePost` — so
     // class `Post` must be able to box the ActionId? Hence it's boxed (above)?
   }
   

与此相关的是这个答案,它说当值类没有逃避范围时,它实际上是内联的.有关详细信息,请参阅Scala改进流程文档SIP-15.但是据我所知,SIP-15实际上没有提到逃避范围的值类实例将被"装箱".但我认为它必须被"盒装"似乎是合理的.(为什么SIP没有明确声明如果它逃脱会被装箱？)

Answer 1

在所有三种情况下都不会有拳击.

你自己检查很容易:

class ActionId(val value: Int) extends AnyVal
object Foo {
  def someFunction(): ActionId = {
    new ActionId(123)
  }
}

现在让我们运行scalac,我们将有一堆类文件(带字节码的文件).我们需要的是Foo\$.

» javap Foo\$ 
Compiled from "Boxing.scala"
public final class Foo$ extends java.lang.Object{
    public static final Foo$ MODULE$;
    public static {};
    public int someFunction();
}

正如您所看到的,即使值类从函数中泄漏,通常它也不会被装箱.

case class Post(id: ActionId, notion: String)

object Foo2 {
  def someFunction(): Post = {
    Post(new ActionId(123), "So ActionID will be boxed?")
  } 
}

scalac => javap:

» javap Post  
Compiled from "Boxing.scala"
public class Post extends java.lang.Object implements scala.Product,scala.Serializable{
    public static scala.Function1 tupled();
    public static scala.Function1 curried();
    public int id();
    public java.lang.String notion();
    public Post copy(int, java.lang.String);
    public int copy$default$1();
    public java.lang.String copy$default$2();
    public java.lang.String productPrefix();
    public int productArity();
    public java.lang.Object productElement(int);
    public scala.collection.Iterator productIterator();
    public boolean canEqual(java.lang.Object);
    public int hashCode();
    public java.lang.String toString();
    public boolean equals(java.lang.Object);
    public Post(int, java.lang.String);
}

正如你可以看到id在这里表示为普通int(例如第三种方法).

最后,如果没有返回具有值类成员的对象(并没有真正逃避范围),那么将值类化为盒子吗？

case class Post(id: ActionId, notion: String)

object Foo3 {
  def anotherFunction(): Unit {
    val post = Post(new ActionId(123), "Will be boxed?")
  } 
}

如果我们仔细查看方法的字节码,我们将看到:

Code:
   Stack=4, Locals=2, Args_size=1
   0:   new #15; //class Post
   3:   dup
   4:   bipush  123
   6:   ldc #17; //String Will be boxed?
   8:   invokespecial   #20; //Method Post."<init>":(ILjava/lang/String;)V
   11:  astore_1
   12:  return
  LocalVariableTable: 
   Start  Length  Slot  Name   Signature
   0      13      0    this       LFoo3$;
   12      0      1    post       LPost;

ActionId中没有int的装箱.如果它会打包你会看到像这样的东西:

Code:
   Stack=5, Locals=2, Args_size=1
   0:   new #15; //class Post
   3:   dup
   4:   new #17; //class ActionId
   7:   dup
   8:   bipush  123
   10:  invokespecial   #20; //Method ActionId."<init>":(I)V
   13:  ldc #22; //String Will be boxed?
   15:  invokespecial   #25; //Method Post."<init>":(LActionId;Ljava/lang/String;)V
   18:  astore_1
   19:  return
  LocalVariableTable: 
   Start  Length  Slot  Name   Signature
   0      20      0    this       LFoo3$;
   19      0      1    post       LPost;

你看,不同的是bipush 123对

   4:   new #17; //class ActionId
   7:   dup
   8:   bipush  123
   10:  invokespecial   #20; //Method ActionId."<init>":(I)V

Answer 2

没有一个例子导致拳击.值类只有泛型,带数组,以及输入超类/特征时(例如Any/AnyVal)

它们装有泛型,因为否则你无法将它们与价值区分开来(而且原语需要一个盒子).与Any相同,其他超类/特征需要一个框或类型关系是错误的.

它们装有数组,因为数组需要知道内容的类型,但JVM不理解"值类型"的概念.所以你最终得到一个数组,说它是盒装的类型,但Scala假装的是一个值类型的数组; 做出了一个决定(基于以前的问题,当它不仅仅是一个普通的Java/JVM阵列时,这会导致太多微妙的错误和角落情况).

以下是获得拳击的三种方法的示例:

trait Q extends Any {}
class X(val x: String) extends AnyVal with Q {}

// Array
val a = Array(new X("salmon"))   // boxed

// Generic
val b = Option(new X("minnow"))  // boxed

// Upcast
val c = (new X("perch"): Any)    // boxed
val d = (new X("cod"): AnyVal)   // boxed
val e = (new X("herring"): Q)    // boxed

其他一切 - 通过各种功能等传递 - 不需要装箱,包括你所有的例子.

数组是一种特殊情况,因为你可以存储基元并将它们作为值类重新拉出来,零字节码开销,但是很多语法开销:

class Y(val repr: String) extends AnyVal {}
val y1 = new Y("apple")    // unboxed
val y2 = new Y("orange")   // unboxed
val ys: Array[String] = Array(y1.repr, y2.repr)   // no overhead
val y3 = new Y(ys(0))      // no overhead