¿Cuál es la diferencia entre JavaConverters y JavaConversions en Scala?
scala-collections scala-java-interop (3)
Como se explica en la API, JavaConversions es un conjunto de conversiones implícitas que transforma las colecciones de Java en una colección de scala relacionada.
Puede usarlo con una import collection.JavaConversions._ . import collection.JavaConversions._ . Cuando sea necesario, el compilador transformará automáticamente la colección de Java en el tipo de scala correcto.
JavaConverters son un conjunto de decoradores que ayuda a transformar las colecciones de java o scala en scala o colecciones java utilizando los métodos asScala o asJava que se agregarán implícitamente a la colección que desee transformar. Para usar estos convertidores, debe importar:
import collection.JavaConverters._
Debería preferir JavaConversions ya que generalmente es más fácil de usar (no es necesario usar asScala o asJava ).
En scala.collection , hay dos objetos muy similares JavaConversions y JavaConverters .
- ¿Cuál es la diferencia entre estos dos objetos?
- ¿Por qué ambos existen?
- ¿Cuándo quiero usar uno frente al otro?
Para cualquier persona que aterrice en esta pregunta desde Scala 2.12.x, JavaConversions ahora está en desuso y JavaConverters es el método preferido.
JavaConversions proporciona una serie de métodos implícitos que convierten entre una colección Java y la colección Scala más cercana correspondiente, y viceversa. Esto se hace creando wrappers que implementan la interfaz de Scala y reenvían las llamadas a la colección de Java subyacente, o la interfaz de Java, reenviando las llamadas a la colección de Scala subyacente.
JavaConverters utiliza el patrón pimp-my-library para "agregar" el método asScala a las colecciones de Java y el método asJava a las colecciones de Scala, que devuelven los contenedores adecuados que se analizaron anteriormente. Es más nuevo (desde la versión 2.8.1) que JavaConversions (desde 2.8) y hace que la conversión entre Scala y la colección de Java sea explícita. Contrariamente a lo que David escribe en su respuesta, le recomiendo que JavaConverters hábito de usar JavaConverters ya que será menos probable que escriba código que JavaConverters muchas conversiones implícitas, ya que puede controlar el único lugar donde suceder: donde escribes .asScala o .asJava .
Aquí están los métodos de conversión que JavaConverters proporciona:
Pimped Type | Conversion Method | Returned Type
=================================================================================================
scala.collection.Iterator | asJava | java.util.Iterator
scala.collection.Iterator | asJavaEnumeration | java.util.Enumeration
scala.collection.Iterable | asJava | java.lang.Iterable
scala.collection.Iterable | asJavaCollection | java.util.Collection
scala.collection.mutable.Buffer | asJava | java.util.List
scala.collection.mutable.Seq | asJava | java.util.List
scala.collection.Seq | asJava | java.util.List
scala.collection.mutable.Set | asJava | java.util.Set
scala.collection.Set | asJava | java.util.Set
scala.collection.mutable.Map | asJava | java.util.Map
scala.collection.Map | asJava | java.util.Map
scala.collection.mutable.Map | asJavaDictionary | java.util.Dictionary
scala.collection.mutable.ConcurrentMap | asJavaConcurrentMap | java.util.concurrent.ConcurrentMap
—————————————————————————————————————————————————————————————————————————————————————————————————
java.util.Iterator | asScala | scala.collection.Iterator
java.util.Enumeration | asScala | scala.collection.Iterator
java.lang.Iterable | asScala | scala.collection.Iterable
java.util.Collection | asScala | scala.collection.Iterable
java.util.List | asScala | scala.collection.mutable.Buffer
java.util.Set | asScala | scala.collection.mutable.Set
java.util.Map | asScala | scala.collection.mutable.Map
java.util.concurrent.ConcurrentMap | asScala | scala.collection.mutable.ConcurrentMap
java.util.Dictionary | asScala | scala.collection.mutable.Map
java.util.Properties | asScala | scala.collection.mutable.Map[String, String]
Sin embargo, para utilizar las conversiones directamente desde Java, es mejor que JavaConversions directamente a los métodos desde JavaConversions ; p.ej:
List<String> javaList = new ArrayList<String>(Arrays.asList("a", "b", "c"));
System.out.println(javaList); // [a, b, c]
Buffer<String> scalaBuffer = JavaConversions.asScalaBuffer(javaList);
System.out.println(scalaBuffer); // Buffer(a, b, c)
List<String> javaListAgain = JavaConversions.bufferAsJavaList(scalaBuffer);
System.out.println(javaList == javaListAgain); // true