加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 (https://www.lidatong.com.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 综合聚焦 > 服务器 > 安全 > 正文

scala – 使用重复参数的成本

发布时间:2020-12-16 09:56:15 所属栏目:安全 来源:网络整理
导读:我考虑重构一些方法签名,这些签名当前采用List类型的参数或具体类的集合–List [Foo] – 来改为使用重复的参数:Foo *. Update : Following reasoning is flawed,move along… This would allow me to use the same method name and overload it based on th
我考虑重构一些方法签名,这些签名当前采用List类型的参数或具体类的集合–List [Foo] – 来改为使用重复的参数:Foo *.

Update: Following reasoning is flawed,move along…
This would allow me to use the same method name and overload it based on the parameter type. This was not possible using List or Set,because List[Foo] and List[Bar] have same type after erasure: List[Object].

在我的情况下,重构的方法适用于scala.Seq [Foo],它来自重复的参数.我必须更改所有调用并将序列参数类型注释添加到所有集合参数:baz.doStuffWith(foos:_ *).

鉴于从集合参数切换到重复参数在语义上是等效的,这个更改是否会产生一些我应该注意的性能影响?

scala 2.7._和2.8的答案是否相同?

解决方法

当 Scala调用 Scala varargs方法时,该方法将接收一个扩展Seq的对象.当使用:_ *进行调用时,对象将按原样传递,而不进行复制.以下是此示例:

scala> object T {
     |   class X(val self: List[Int]) extends SeqProxy[Int]  {
     |     private val serial = X.newSerial
     |     override def toString = serial.toString+":"+super.toString
     |   }
     |   object X {
     |     def apply(l: List[Int]) = new X(l)
     |     private var serial = 0
     |     def newSerial = {
     |       serial += 1
     |       serial
     |     }
     |   }
     | }
defined module T

scala> new T.X(List(1,2,3))
res0: T.X = 1:List(1,3)

scala> new T.X(List(1,3))
res1: T.X = 2:List(1,3)

scala> def f(xs: Int*) = xs.toString
f: (Int*)String

scala> f(res0: _*)
res3: String = 1:List(1,3)

scala> f(res1: _*)
res4: String = 2:List(1,3)

scala> def f(xs: Int*): Seq[Int] = xs
f: (Int*)Seq[Int]

scala> def f(xs: Int*) = xs match {
     |   case ys: List[_] => println("List")
     |   case _ => println("Something else")
     | }
f: (Int*)Unit

scala> f(List(1,3): _*)
List

scala> f(res0: _*)
Something else

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> def f(xs: Int*) = xs match {
     |   case ys: List[_] => println("List")
     |   case zs: ArrayBuffer[_] => zs.asInstanceOf[ArrayBuffer[Int]] += 4; println("Array Buffer")
     |   case _ => println("Something else")
     | }
f: (Int*)Unit

scala> val ab = new ArrayBuffer[Int]()
ab: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> ab + 1
res11: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1)

scala> ab + 2
res12: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1,2)

scala> ab + 3
res13: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1,3)

scala> f(ab: _*)
Array Buffer

scala> ab
res15: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,3,4)

注意

> Array作为WrappedArray传递.但是,不会复制所涉及的元素,并且对WrappedArray的更改将反映在数组中.

(编辑:李大同)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章
      热点阅读