Convert scala.List[scala.Long] to List<java.util.Long>

Question

In my Scala code I need to interact with Java libraries.

The method I want to use expects parameter of type List<java.util.Long> , but I have Scala type Option[List[Long]] . The problem I faced is that I need manually apply Predef.long2Long function to convert from Scala Long to java.util.Long :

val userIds = Option(List(1,2,3,4))
val methodParameter = userIds.map(list => list.map(long2Long).asJava).orNull

is there some way to convert this list in more elegant and concise way?

EDIT: I can even simplify question: how to convert Option[scala.Boolean] to java.util.Boolean ? Here I need to do same:

isUsed.map(isUsedVal => boolean2Boolean(isUsedVal)).orNull,

Answer 1

For the List[Long] :

import scala.collection.JavaConverters._

val l = List(1L,2L,3L,4L)

l.map(java.lang.Long.valueOf).asJava
// or 
l.map(_.asInstanceOf[AnyRef]).asJava
// or
l.map(Long.box).asJava

For the Option[Boolean] :

val mb = Some(true)

mb.map(java.lang.Boolean.valueOf).orNull
// or 
mb.map(_.asInstanceOf[AnyRef]).orNull
// or 
mb.map(Boolean.box).orNull

Answer 2

Can you use JavaConverters ? and do something like that

val sl = new scala.collection.mutable.ListBuffer[Int]
val jl : java.util.List[Int] = sl.asJava

Answer 3

It's worth mentioning that long2Long and boolean2Boolean are implicit, but that doesn't help you much to make this more elegant or clear, I think. It does allow you to things like:

type JB = java.lang.Boolean
isUsed.fold(null : JB)(implicitly)
//Or:
isUsed.map { b => b : JB }.orNull
//Or even:
isUsed.map[JB](identity).orNull

But that's not particularly readable, in my opinion.

These sorts of methods are perfect candidates for an implicit class method . You can enrich your classes with these methods so that you only have to write the tedious or inelegant code once. For example, you might consider:

object MoreJavaConversions {
    import scala.collection.JavaConverters._
    implicit class RichListLong(val list: Option[List[Long]]) extends AnyVal {
        def asJava : java.util.List[java.lang.Long] = list.map(_.map(long2Long).asJava).orNull
    }
    implicit class RichOptionBoolean(val bool: Option[Boolean]) extends AnyVal {
        def asJava : java.lang.Boolean = bool.map(boolean2Boolean).orNull
    }
}

Which would later allow you to do:

import MoreJavaConversions._
val myUsers = Option(List(1l, 2l, 3l))

myUsers.asJava //java.util.List[java.lang.Long]
Option(true).asJava //java.lang.Boolean