Scala Language
Interoperabilidad de Java

Conversión de colecciones Scala a colecciones Java y viceversa

Cuando necesite pasar una colección a un método Java:

import scala.collection.JavaConverters._

val scalaList = List(1, 2, 3)
JavaLibrary.process(scalaList.asJava)

Si el código Java devuelve una colección Java, puede convertirlo en una colección Scala de una manera similar:

import scala.collection.JavaConverters._

val javaCollection = JavaLibrary.getList
val scalaCollection = javaCollection.asScala

Tenga en cuenta que estos son decoradores, por lo que simplemente envuelven las colecciones subyacentes en una interfaz de colección de Scala o Java. Por lo tanto, las llamadas .asJava y .asScala no copian las colecciones.

Arrays

Las matrices son matrices JVM regulares con un giro que se tratan como invariantes y tienen constructores especiales y conversiones implícitas. Constrúyelos sin la new palabra clave.

 val a = Array("element")

Ahora tiene a tipo Array[String] .

 val acs: Array[CharSequence] = a
 //Error: type mismatch;  found   : Array[String]  required: Array[CharSequence]

Aunque String se puede convertir en CharSequence , Array[String] no se puede convertir en Array[CharSequence] .

Puede usar un Array como otras colecciones, gracias a una conversión implícita a TraversableLike ArrayOps :

 val b: Array[Int] = a.map(_.length)

La mayoría de las colecciones de Scala ( TraversableOnce ) tienen un método toArray que toma un ClassTag implícito para construir la matriz de resultados:

 List(0).toArray
 //> res1: Array[Int] = Array(0)

Esto facilita el uso de TraversableOnce en su código de Scala y luego lo pasa al código Java que espera una matriz.

Conversiones de tipo Scala y Java

Scala ofrece conversiones implícitas entre todos los principales tipos de colección en el objeto JavaConverters.

Las siguientes conversiones de tipo son bidireccionales.

Algunas otras colecciones de Scala también se pueden convertir a Java, pero no tienen una conversión al tipo de Scala original:

Referencia :

Conversiones entre colecciones de Java y Scala

Interfaces funcionales para funciones de Scala - scala-java8-compat

Un kit de compatibilidad de Java 8 para Scala.

La mayoría de los ejemplos se copian de Readme

Convertidores entre scala.FunctionN y java.util.function

import java.util.function._
import scala.compat.java8.FunctionConverters._

val foo: Int => Boolean = i => i > 7
def testBig(ip: IntPredicate) = ip.test(9)
println(testBig(foo.asJava))  // Prints true

val bar = new UnaryOperator[String]{ def apply(s: String) = s.reverse }
List("cod", "herring").map(bar.asScala)    // List("doc", "gnirrih")

def testA[A](p: Predicate[A])(a: A) = p.test(a)
println(testA(asJavaPredicate(foo))(4))  // Prints false

Convertidores entre las clases scala.Option y java.util Optional, OptionalDouble, OptionalInt y OptionalLong.

import scala.compat.java8.OptionConverters._

    class Test {
      val o = Option(2.7)
      val oj = o.asJava        // Optional[Double]
      val ojd = o.asPrimitive  // OptionalDouble
      val ojds = ojd.asScala   // Option(2.7) again
    }

Convertidores de colecciones de Scala a Java 8 Streams

import java.util.stream.IntStream

import scala.compat.java8.StreamConverters._
import scala.compat.java8.collectionImpl.{Accumulator, LongAccumulator}


  val m = collection.immutable.HashMap("fish" -> 2, "bird" -> 4)
  val parStream: IntStream = m.parValueStream
  val s: Int = parStream.sum
  // 6, potientially computed in parallel
  val t: List[String] = m.seqKeyStream.toScala[List]
  // List("fish", "bird")
  val a: Accumulator[(String, Int)] = m.accumulate // Accumulator[(String, Int)]

  val n = a.stepper.fold(0)(_ + _._1.length) +
    a.parStream.count // 8 + 2 = 10

  val b: LongAccumulator = java.util.Arrays.stream(Array(2L, 3L, 4L)).accumulate
  // LongAccumulator
  val l: List[Long] = b.to[List] // List(2L, 3L, 4L)