Scala Language
Interoperabilità Java

Conversione di collezioni Scala in raccolte Java e viceversa

Quando è necessario passare una raccolta in un metodo Java:

import scala.collection.JavaConverters._

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

Se il codice Java restituisce una raccolta Java, è possibile trasformarla in una raccolta Scala in un modo simile:

import scala.collection.JavaConverters._

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

Si noti che questi sono decoratori, quindi si limitano a racchiudere le raccolte sottostanti in un'interfaccia di raccolta Scala o Java. Pertanto, le chiamate .asJava e .asScala non copiano le raccolte.

Array

Gli array sono normali array JVM con un tocco che sono trattati come invarianti e hanno costruttori speciali e conversioni implicite. Costruiscile senza la new parola chiave.

 val a = Array("element")

Ora a ha tipo Array[String] .

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

Sebbene String sia convertibile in CharSequence , Array[String] non è convertibile in Array[CharSequence] .

Puoi utilizzare una Array come altre raccolte, grazie a una conversione implicita a TraversableLike ArrayOps :

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

La maggior parte delle collezioni Scala ( TraversableOnce ) hanno un toArray metodo di prendere un implicito ClassTag per costruire la matrice risultato:

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

Ciò semplifica l'uso di qualsiasi TraversableOnce nel tuo codice Scala e poi lo passa al codice Java che si aspetta un array.

Conversioni di tipo Scala e Java

Scala offre conversioni implicite tra tutti i principali tipi di raccolta nell'oggetto JavaConverters.

Le seguenti conversioni di tipi sono bidirezionali.

Alcune altre collezioni Scala possono anche essere convertite in Java, ma non hanno una conversione al tipo Scala originale:

Riferimento :

Conversioni tra le raccolte Java e Scala

Interfacce funzionali per le funzioni di Scala - scala-java8-compat

Un kit di compatibilità Java 8 per Scala.

La maggior parte degli esempi viene copiata da Readme

Convertitori tra scala.FunctionN e 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

Convertitori tra scale.Option e le classi java.util Facoltativo, OpzionaleDouble, OpzionaleInt e OpzionaleLungo.

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
    }

Convertitori da collezioni Scala a Java 8 Stream

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)