Ho bisogno di convertire l'opzione Scala in Java Opzionale. Sono riuscito a scrivere questo:Convertire l'opzione Scala in Java Opzionale
public <T> Optional<T> convertOption2Optional(Option<T> option) {
return option.isDefined() ? Optional.of(option.get()) : Optional.empty();
}
Ma non mi piace.
C'è un modo semplice per farlo o un convertitore di scala incorporato? Sto cercando qualcosa di simile:
Options.asJava(option);
La via più breve che posso pensare in Java è:
Optional.ofNullable(option.getOrElse(null))
@ RégisJean-Gilles in realtà suggerito ancora più breve se si sta scrivendo la conversione in Scala :
Optional.ofNullable(option.orNull)
Tra l'altro si deve sapere che Scala non supporta Java 8 fino Scala 2.12, che non è ancora ufficialmente fuori. Guardando il docs (che può cambiare fino al rilascio) non esiste tale conversione in JavaConversions.
Certo, questo è il motivo per cui non sono riuscito a trovarlo lì :) – mjjaniec
Solo una nota, non è consigliabile l'uso 'JavaConversions' affatto. 'JavaConverters' è un modo preferibile. Ad ogni modo nessuno dei due supporta 'Optional' al momento – dk14
@ dk14 raccomandato da chi, e perché? Per quanto posso dire, fanno rigorosamente la stessa cosa con una sintassi leggermente diversa. 'JavaConverters' fornisce probabilmente una sintassi migliore, ma funziona solo dal codice Scala, non dal codice Java che tenta di convertire le raccolte Scala poiché Java non supporta impliciti. Non c'è niente di sbagliato in 'JavaConversions' – Dici
È inoltre possibile utilizzare alcune delle abbondanti utilità là fuori sul GitHub, ad esempio:
java8 compat non ottiene abbastanza esposizione. –
sto facendo questo:
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()
}
}
}
così, può usarlo in questo modo :)
import myscala._
object Main extends App {
val scalaOption = java.util.Optional.ofNullable("test").asScala
println(scalaOption)
val javaOption = Option("test").asJava
println(javaOption)
}
Un'altra bella lib:
https://github.com/AVSystem/scala-commons
import com.avsystem.commons.jiop.JavaInterop._
Optional.of("anything").asScala
Per un determinato parametro di ingresso opt: Option[T] di una classe, è possibile definire un metodo all'interno di quella classe come la seguente:
def toOptional(implicit ev: Null <:< T): Optional[T] = Optional.ofNullable(opt.orNull).
Perché non si crea un metodo statico 'asJava (opzione opt)' in una classe 'Opzioni' definita dall'utente? –
Potrei, ma questo è un altro pezzo di codice da mantenere, mi piacerebbe usare "standard way" – mjjaniec