Scala Language
Interopérabilité Java

Conversion de collections Scala en collections Java et vice versa

Lorsque vous devez transmettre une collection dans une méthode Java:

import scala.collection.JavaConverters._

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

Si le code Java renvoie une collection Java, vous pouvez la transformer en une collection Scala de la même manière:

import scala.collection.JavaConverters._

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

Notez que ce sont des décorateurs, donc ils encapsulent simplement les collections sous-jacentes dans une interface de collection Scala ou Java. Par conséquent, les appels .asJava et .asScala ne copient pas les collections.

Tableaux

Les tableaux sont des tableaux JVM classiques avec une torsion qu'ils sont traités comme des invariants et ont des constructeurs spéciaux et des conversions implicites. Construisez-les sans le new mot-clé.

 val a = Array("element")

Maintenant, a type a Array[String] .

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

Bien que String soit convertible en CharSequence , Array[String] n'est pas convertible en Array[CharSequence] .

Vous pouvez utiliser un Array comme les autres collections, grâce à une conversion implicite en TraversableLike ArrayOps :

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

La plupart des collections Scala ( TraversableOnce ) ont une méthode toArray prenant un ClassTag implicite pour construire le tableau de résultats:

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

Cela facilite l'utilisation de TraversableOnce dans votre code Scala, puis le transmet au code Java qui attend un tableau.

Conversions de type Scala et Java

Scala propose des conversions implicites entre tous les principaux types de collection de l'objet JavaConverters.

Les conversions de type suivantes sont bidirectionnelles.

Certaines autres collections Scala peuvent également être converties en Java, mais ne sont pas reconverties au type Scala d'origine:

Référence :

Conversions entre les collections Java et Scala

Interfaces fonctionnelles pour les fonctions Scala - scala-java8-compat

Un kit de compatibilité Java 8 pour Scala.

La plupart des exemples sont copiés à partir de Readme

Convertisseurs entre scala.FunctionN et 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

Convertisseurs entre les classes scala.Option et java.util Facultatif, OptionalDouble, OptionalInt et 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
    }

Convertisseurs de collections Scala en 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)