Совместная работа с Java/Scala (глубокими) коллекциями

Ответ 1

Метод для этого изменился с 2.7 до 2.8. Метод ретроним хорошо работает для 2.8. Для 2.7 вместо этого используйте collections.jcl следующим образом:

object Example {
  import scala.collection.jcl

  // Build the example data structure
  val row1 = new java.util.ArrayList[Double]()
  val row2 = new java.util.ArrayList[Double]()
  val mat = new java.util.ArrayList[java.util.ArrayList[Double]]()
  row1.add(1.0) ; row1.add(2.0) ; row2.add(3.0) ; row2.add(4.0)
  mat.add(row1) ; mat.add(row2)
  val named = new java.util.HashMap[String,java.util.ArrayList[java.util.ArrayList[Double]]]
  named.put("matrix",mat)

  // This actually does the conversion
  def asScala(thing: java.util.HashMap[String,java.util.ArrayList[java.util.ArrayList[Double]]]) = {
    Map() ++ (new jcl.HashMap(thing)).map(kv => {
      ( kv._1 ,
        (new jcl.ArrayList(kv._2)).map(al => {
          (new jcl.ArrayList(al)).toArray
        }).toArray
      )
    })
  }
}

Итак, общая идея такова: извне внутри, оберните коллекцию Java в эквиваленте Scala, затем используйте карту, чтобы обернуть все на следующем уровне. Если вы хотите конвертировать между представлениями Scala, сделайте это на выходе (здесь, .toArray на концах).

И здесь вы можете увидеть пример работы:

scala> Example.named
res0: java.util.HashMap[String,java.util.ArrayList[java.util.ArrayList[Double]]] = {matrix=[[1.0, 2.0], [3.0, 4.0]]}

scala> val sc = Example.asScala(Example.named)
sc: scala.collection.immutable.Map[String,Array[Array[Double]]] = Map(matrix -> Array([[email protected], [[email protected]))

scala> sc("matrix")(0)
res1: Array[Double] = Array(1.0, 2.0)

scala> sc("matrix")(1)
res2: Array[Double] = Array(3.0, 4.0)

Ответ 2

Я не утверждаю, что все это элегантно, но оно работает. Я использую преобразования из JavaConversions явно, а не неявно, чтобы разрешить вывод типа, чтобы помочь немного. JavaConversions является новым в Scala 2.8.

import collection.JavaConversions._
import java.util.{ArrayList, HashMap}
import collection.mutable.Buffer

val javaMutable = new HashMap[String, ArrayList[ArrayList[Double]]]

val scalaMutable: collection.Map[String, Buffer[Buffer[Double]]] =
    asMap(javaMutable).mapValues(asBuffer(_).map(asBuffer(_)))

val scalaImmutable: Map[String, List[List[Double]]] =
    Map(asMap(javaMutable).mapValues(asBuffer(_).map(asBuffer(_).toList).toList).toSeq: _*)

UPDATE. Вот альтернативный подход, который использует implicits для применения заданного набора преобразований к произвольно вложенной структуре.

trait ==>>[A, B] extends (A => B) {
  def apply(a: A): B
}

object ==>> {
  def convert[A, B](a: A)(implicit a2b: A ==>> B): B = a

  // the default identity conversion
  implicit def Identity_==>>[A] = new (A ==>> A) {
    def apply(a: A) = a
  }

  // import whichever conversions you like from here:
  object Conversions {
    import java.util.{ArrayList, HashMap}
    import collection.mutable.Buffer
    import collection.JavaConversions._

    implicit def ArrayListToBuffer[T, U](implicit t2u: T ==>> U) = new (ArrayList[T] ==>> Buffer[U]) {
      def apply(a: ArrayList[T]) = asBuffer(a).map(t2u)
    }

    implicit def HashMapToMap[K, V, VV](implicit v2vv: V ==>> VV) = new (HashMap[K, V] ==>> collection.Map[K, VV]) {
      def apply(a: java.util.HashMap[K, V]) = asMap(a).mapValues(v2vv)
    }
  }
}

object test {
  def main(args: Array[String]) {

    import java.util.{ArrayList, HashMap}
    import collection.mutable.Buffer

    // some java collections with different nesting
    val javaMutable1 = new HashMap[String, ArrayList[ArrayList[Double]]]
    val javaMutable2 = new HashMap[String, ArrayList[HashMap[String, ArrayList[ArrayList[Double]]]]]

    import ==>>.{convert, Conversions}
    // here comes the elegant part!
    import Conversions.{HashMapToMap, ArrayListToBuffer}
    val scala1 = convert(javaMutable1)
    val scala2 = convert(javaMutable2)

    // check the types to show that the conversion worked.
    scala1: collection.Map[String, Buffer[Buffer[Double]]]
    scala2: collection.Map[String, Buffer[collection.Map[String, Buffer[Buffer[Double]]]]]
  }
}

Ответ 3

@retronym ответ хорош, если ваши коллекции однородны, но, похоже, это не работало для меня, когда у меня была смешанная коллекция. Например:

val x = Map(5 -> Array(1, List(2, 7), 3), 6 -> Map(5 -> List(7, 8, 9)))

Чтобы преобразовать такую ​​коллекцию в java, вам нужно полагаться на типы времени выполнения, потому что тип x не является тем, что можно рекурсивно преобразовать в java во время компиляции. Вот метод, который может обрабатывать преобразование смешанных коллекций scala в java:

  def convert(x:Any):Any =
  {
    import collection.JavaConversions._
    import collection.JavaConverters._
    x match
    {   
      case x:List[_] => x.map{convert}.asJava
      case x:collection.mutable.ConcurrentMap[_, _] => x.mapValues(convert).asJava
      case x:collection.mutable.Map[_, _] => x.mapValues(convert).asJava
      case x:collection.immutable.Map[_, _] => x.mapValues(convert).asJava
      case x:collection.Map[_, _] => x.mapValues(convert).asJava
      case x:collection.mutable.Set[_] => x.map(convert).asJava
      case x:collection.mutable.Buffer[_] => x.map(convert).asJava
      case x:Iterable[_] => x.map(convert).asJava
      case x:Iterator[_] => x.map(convert).asJava
      case x:Array[_] => x.map(convert).toArray
      case _ => x
    }   
  }

Аналогичный метод можно записать для преобразования из java в scala.

Обратите внимание, что возвращаемый тип этого метода равен Any, поэтому для использования возвращаемого значения вам может потребоваться выполнить приведение: val y = convert(x).asInstanceOf[java.util.Map[Int, Any]].