Convert Scala Option to Java Optional

Question

I need to convert Scala Option to Java Optional. I managed to wrote this:

public <T> Optional<T> convertOption2Optional(Option<T> option) {
    return option.isDefined() ? Optional.of(option.get()) : Optional.empty();
}

But I don't like it.

Is there a simple way to do it, or a built-in scala converter? I'm looking for something like:

Options.asJava(option);

Answer 1

You can also use some of the abundant utilities out there on the github, e.g.:

https://gist.github.com/julienroubieu/fbb7e1467ab44203a09f

https://github.com/scala/scala-java8-compat

Answer 2

Starting Scala 2.13, there is a dedicated converter from scala's Option to java's Optional.

From Java (the explicit way):

import scala.jdk.javaapi.OptionConverters;

// val option: Option[Int] = Some(42)
OptionConverters.toJava(option);
// java.util.Optional[Int] = Optional[42]

From Scala (the implicit way):

import scala.jdk.OptionConverters._

// val option: Option[Int] = Some(42)
option.toJava
// java.util.Optional[Int] = Optional[42]

Answer 3

The shortest way I can think of in Java is:

Optional.ofNullable(option.getOrElse(null))

@RégisJean-Gilles actually suggested even shorter if you are writing the conversion in Scala:

Optional.ofNullable(option.orNull)

By the way you must know that Scala does not support Java 8 until Scala 2.12, which is not officially out yet. Looking at the docs (which may change until the release) there is no such conversion in JavaConversions.

Answer 4

There is an asJava solution now! It's available from 2.10.

Example:

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
}

More details here.

Answer 5

I am doing this:

import java.util.{Optional => JOption}

package object myscala {

    implicit final class RichJOption[T](val optional: JOption[T]) {

        def asScala: Option[T] = optional match {
            case null => null
            case _ => if (optional.isPresent) Option(optional.get()) else None
        }

    }

    implicit final class RichOption[T](val option: Option[T]) {

        def asJava: JOption[T] = option match {
            case null => null
            case _ => if (option.isDefined) JOption.of(option.get) else JOption.empty()
        }

    }
}

so, you can use it like this, :)

import myscala._

object Main extends App {

    val scalaOption = java.util.Optional.ofNullable("test").asScala
    println(scalaOption)

    val javaOption = Option("test").asJava
    println(javaOption)

}

Answer 6

Another nice lib:

https://github.com/AVSystem/scala-commons

import com.avsystem.commons.jiop.JavaInterop._
Optional.of("anything").asScala