complejidad Hora del método JavaConverters asScala

Question

A partir de Scala versión 2.9 existe un convertidor práctico para convertir de java.util.List y otras colecciones a las estructuras de datos de Scala escribiendo algo como esto:

import scala.collection.JavaConverters._ 
def scalaVersion = callJavaMethod.asScala 

Ésta es una característica poco preciosa, ya que le permite a uno aprovechar las ventajas de Scala cuando interactúa con el código Java existente.

Sin embargo, estoy seguro acerca de los involucrados complejidad del tiempo y el espacio y no pudo encontrar nada en la documentación oficial, por lo tanto, la siguiente pregunta:

¿Dónde puedo obtener información sobre la complejidad (tiempo y espacio) de los JavaConverters?

Answer 1

Varias clases JavaConverters están utilizando el patrón Adapter para envolver la colección Java original (underlying) y proporcionan la interfaz Scala. Por lo tanto, tanto la conversión como el acceso a las colecciones convertidas es constante en el tiempo (O(1)) introduciendo solo gastos indirectos menores.

Por ejemplo este es el código fuente completo de JListWrapper:

case class JListWrapper[A](val underlying : java.util.List[A]) extends mutable.Buffer[A] { 
    def length = underlying.size 
    override def isEmpty = underlying.isEmpty 
    override def iterator : Iterator[A] = underlying.iterator 
    def apply(i : Int) = underlying.get(i) 
    def update(i : Int, elem : A) = underlying.set(i, elem) 
    def +=:(elem : A) = { underlying.subList(0, 0).add(elem) ; this } 
    def +=(elem : A): this.type = { underlying.add(elem); this } 
    def insertAll(i : Int, elems : Traversable[A]) = { val ins = underlying.subList(0, i) ; elems.seq.foreach(ins.add(_)) } 
    def remove(i : Int) = underlying.remove(i) 
    def clear = underlying.clear 
    def result = this 
} 

También tenga en cuenta que la conversión de la colección de Java para Scala y luego de vuelta a Java produce la colección original, no de doble envoltura.