Konvertieren Scala Option, um Java Optional

Muss ich konvertieren Scala Option, um Java Optional. Ich schaffte es schrieb:

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

Aber ich mag es nicht.

Gibt es eine einfache Möglichkeit, es zu tun, oder eine built-in-scala-Konverter?
Ich bin auf der Suche nach etwas wie:

Options.asJava(option);

Warum nicht erstellen Sie einfach eine statische Methode asJava(Option<T> opt) in einem selbst definierten Options Klasse?
Ich könnte, aber das ist ein anderes Stück code zu erhalten, würde ich gerne den "standard-Weg"

InformationsquelleAutor mjjaniec | 2016-07-12

10

Den kürzesten Weg, die ich denken kann, in Java ist:
```
Optional.ofNullable(option.getOrElse(null))
```
@RégisJean-Gilles tatsächlich vorgeschlagen, sogar noch kürzer, wenn Sie sind das schreiben der Umwandlung in Scala:
```
Optional.ofNullable(option.orNull)
```
Übrigens müssen Sie wissen, dass die Scala kein Java 8 bis Scala 2.12, die ist nicht offiziell noch raus. Blick auf die docs (das kann sich ändern bis zum release) es gibt keine solche Umwandlung in JavaConversions.
- Sicher, das ist, warum ich konnte nicht finden es gibt 🙂
- Nur eine Anmerkung, ist es nicht empfohlen zu verwenden JavaConversions überhaupt. JavaConverters ist ein bevorzugter Weg. Jedenfalls weder von Ihnen unterstützt Optional an der Zeit
- empfohlen von der who, und warum ? Soweit ich sagen kann, Sie tun konsequent das gleiche mit einer etwas anderen syntax. JavaConverters wohl eine schönere syntax, aber das funktioniert nur von Scala-code, nicht aus Java-code konvertieren möchten Scala collections seit Java nicht unterstützt implicits. Es ist nichts falsch mit JavaConversions
- href="http://googlyadventures.blogspot.com/2015/06/today-i-learned-javaconverters-vs.html" >googlyadventures.blogspot.com/2015/06/... stackoverflow.com/questions/8301947/... kann ich google den ganzen Tag. Im Grunde JavaConvertions sind auch implizite, sind Sie nicht immer sicher sind, welche Sammlung Sie haben Java oder Scala, und auch IDE können nicht helfen mit, dass
- dies wird nur von den Scala-code, nicht aus Java-code" keiner von Ihnen die Arbeit von Java-Code, da BEIDE von Ihnen verwenden implicits. Die richtige Weise zu tun, von der es Java ist scala.collection.convert - Paket: stackoverflow.com/a/27110969/1809978. Es ist der richtige Weg, weil beide JavaConvertios und JavaConverters tatsächlich, es zu verwenden. und eigentlich sind DSLs für die
- Ich habe auf jeden Fall verwendet werden JavaConversions von Java-code aus, aber du hast Recht, es nutzt implicits zu. Sie können tatsächlich nutzen es sowieso, durch den Aufruf explizit in diese Methoden, meine bad. Allerdings bin ich mir nicht sicher, ich bin stark kaufen das argument der blogger. Ich denke, in beiden Fällen werden Sie wissen, den Typ des zurückgegebenen Objekts, und Sie den Fall einfach überprüfen, indem er die Scala-compiler netter Typ-Inferenz-Funktion (in der Regel erfordern lediglich den Mauszeiger auf die variable, um zu sehen, seine Art, eine IDE -)
- option.getOrElse(null) verkürzt werden kann, um option.orNull
- stackoverflow.com/questions/38320708/...
- da Sie offenbar wurden in der Nähe der deprecation-Prozess, können Sie uns sagen, die Motivationen ?
- danke, ist Hinzugefügt, um die Antwort
- Streichung von JavaConversions? Es ist ein Hinweis auf scala-lang.org/api/2.12.0-M5/scala/collection/... . Im Grunde, entweder bekommen Sie mehrere Konvertierungen unerwartet; oder Inferenz leidet.
- Ich weiß nicht wirklich sehen, wie ist dies anders. Es ist nicht wie asJava oder asScala sagt, dass Sie die konkrete Art, die zurückgegeben wird. Sie wissen noch nicht, ob Sie werden am Ende mit einem Arraylist oder eine LinkedList zum Beispiel. Nicht Sie haben zu prüfen, doc oder verwenden Sie die compiler-Inferenz in beiden Fällen, um zu bestimmen, die zugrunde liegende Typ ? Und selbst dann wird es nur geben Ihnen ein interface-Typ, nicht die wirklichen konkreten Typ. Trotzdem, vielen Dank
- Ich dachte, der unerwartete mehrere Konvertierungen in eine expr, aber googeln scala javaconversions böse Renditen gist.github.com/xuwei-k/8870ea35c4bb6a4de05c, die ist ziemlich gut. Ich sollte hinzufügen, ich habe keine starke Gefühle über Sie und Jason Zaugg denkt, dass es nützlich für die Prägnanz. Die Streichung wurde weitgehend, um zu helfen Neulinge zu vermeiden, fallen (IMO).
- cool, vielen Dank für die Zeit nehmen, dies zu erklären. Es muss ziemlich cool, um in der Nähe von so einem Projekt, ich bin ein bisschen neidisch 😀
- Der erste funktioniert nicht im Java. None.getOrElse(null) wirft eine NPE weil getOrElse nimmt einen by-name-argument, was übersetzt eine scala.Function0.
- Funktioniert für mich vollkommen in Ordnung: Welcome to Scala version 2.11.6 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_181). Type in expressions to have them evaluated. Type :help for more information. scala> Optional.ofNullable(None.getOrElse(null)) res4: java.util.Optional[Null] = Optional.empty
- Ich sagte: Java. Man wird es in ein Scala-interpreter.
InformationsquelleAutor Dici

Es ist ein asJava Lösung jetzt! Es ist verfügbar auf 2.10.

Beispiel:

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
}

Mehr details hier.

InformationsquelleAutor Java Xu

3

Können Sie auch einige der reichlich Dienstprogramme auf der github, z.B.:

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

https://github.com/scala/scala-java8-compat
- java8 compat nicht genug Exposition.
InformationsquelleAutor Michal M

Ich bin, dies zu tun:

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, Sie können es verwenden, wie diese 🙂

import myscala._

object Main extends App {

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

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

}

InformationsquelleAutor Zhuo YING

Ab Scala 2.13 es ist ein engagierter Konverter von scala Option zu java Optional.

Von Java (die explizite Weg):

import scala.jdk.javaapi.OptionConverters;

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

Von Scala (die implizite Weg):

import scala.jdk.OptionConverters._

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

InformationsquelleAutor Xavier Guihot

1

Für eine gegebene Eingabe-parameter opt: Option[T] einige Klasse,
definieren Sie eine Methode in dieser Klasse wie die folgenden:

def toOptional(implicit ev: Null <:< T): Optional[T] = Optional.ofNullable(opt.orNull).

InformationsquelleAutor Hari Bage
-1

Andere nette lib:

https://github.com/AVSystem/scala-commons
```
import com.avsystem.commons.jiop.JavaInterop._
Optional.of("anything").asScala
```
InformationsquelleAutor mjjaniec

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.