W scala.collection
istnieją dwa bardzo podobne przedmioty JavaConversions
i JavaConverters
.
- Jaka jest różnica między tymi dwoma obiektami?
- Dlaczego oboje istnieją?
- Kiedy chcę używać jednego kontra drugiego?
W scala.collection
istnieją dwa bardzo podobne przedmioty JavaConversions
i JavaConverters
.
Odpowiedzi:
EDYCJA: Java Conversions
dostałem się @deprecated
do Scali 2.13.0. Zamiast tego użyj scala.jdk.CollectionConverters .
JavaConversions
udostępnia szereg niejawnych metod, które konwertują między kolekcją Java a najbliższą odpowiednią kolekcją Scala i odwrotnie. Odbywa się to poprzez tworzenie opakowań, które implementują interfejs Scala i przekazują wywołania do podstawowej kolekcji Java lub interfejs Java, przekazując wywołania do podstawowej kolekcji Scala.
JavaConverters
używa wzorca pimp-my-library, aby „dodać” asScala
metodę do kolekcji Java i asJava
metodę do kolekcji Scala, które zwracają odpowiednie opakowania omówione powyżej. Jest nowszy (od wersji 2.8.1) niż JavaConversions
(od 2.8) i wyraźnie określa konwersję między Scalą a kolekcją Java. W przeciwieństwie do tego, co pisze David w swojej odpowiedzi, zalecam, abyś przyzwyczaił się go używać, JavaConverters
ponieważ znacznie rzadziej będziesz pisać kod, który dokonuje wielu niejawnych konwersji, ponieważ możesz kontrolować jedyne miejsce, w którym to się stanie. : gdzie piszesz .asScala
lub .asJava
.
Oto metody konwersji, które JavaConverters
zapewniają:
Pimped Type | Conversion Method | Returned Type
=================================================================================================
scala.collection.Iterator | asJava | java.util.Iterator
scala.collection.Iterator | asJavaEnumeration | java.util.Enumeration
scala.collection.Iterable | asJava | java.lang.Iterable
scala.collection.Iterable | asJavaCollection | java.util.Collection
scala.collection.mutable.Buffer | asJava | java.util.List
scala.collection.mutable.Seq | asJava | java.util.List
scala.collection.Seq | asJava | java.util.List
scala.collection.mutable.Set | asJava | java.util.Set
scala.collection.Set | asJava | java.util.Set
scala.collection.mutable.Map | asJava | java.util.Map
scala.collection.Map | asJava | java.util.Map
scala.collection.mutable.Map | asJavaDictionary | java.util.Dictionary
scala.collection.mutable.ConcurrentMap | asJavaConcurrentMap | java.util.concurrent.ConcurrentMap
—————————————————————————————————————————————————————————————————————————————————————————————————
java.util.Iterator | asScala | scala.collection.Iterator
java.util.Enumeration | asScala | scala.collection.Iterator
java.lang.Iterable | asScala | scala.collection.Iterable
java.util.Collection | asScala | scala.collection.Iterable
java.util.List | asScala | scala.collection.mutable.Buffer
java.util.Set | asScala | scala.collection.mutable.Set
java.util.Map | asScala | scala.collection.mutable.Map
java.util.concurrent.ConcurrentMap | asScala | scala.collection.mutable.ConcurrentMap
java.util.Dictionary | asScala | scala.collection.mutable.Map
java.util.Properties | asScala | scala.collection.mutable.Map[String, String]
Aby korzystać z konwersji bezpośrednio z Javy, lepiej jest wywoływać metody JavaConversions
bezpośrednio; na przykład:
List<String> javaList = new ArrayList<String>(Arrays.asList("a", "b", "c"));
System.out.println(javaList); // [a, b, c]
Buffer<String> scalaBuffer = JavaConversions.asScalaBuffer(javaList);
System.out.println(scalaBuffer); // Buffer(a, b, c)
List<String> javaListAgain = JavaConversions.bufferAsJavaList(scalaBuffer);
System.out.println(javaList == javaListAgain); // true
JavaConversions
są wygodne, możesz szybko przeoczyć wszystkie miejsca, w których kompilator może je wstawić. Kontrolujesz te miejsca za pomocą JavaConverters
. To cała dyskusja na temat konwersji domyślnej vs. jawnej.
import JavaConversions._
, konwersje nie wystąpią, więc masz kontrolę nad tym, co jest konwertowane. Jeśli umieścisz import w odpowiedni sposób (tylko w razie potrzeby), masz pełną kontrolę nad tym, gdzie konwersja jest wykonywana.
JavaConverters
sobie masz dodatkowe bezpieczeństwo, że nic się nie dzieje, chyba że napiszesz to wprost. To dodatkowe zabezpieczenie i prawdopodobnie dlatego dodano tę klasę.
Dla każdego, kto wyląduje na tym pytaniu od wersji 2.12.x Scala, JavaConversions
jest on obecnie nieaktualny i JavaConverters
jest preferowaną metodą.
JavaConverters
jest przestarzała i scala.jdk.CollectionConverters
jest preferowaną metodą;)
W Scali 2.13 JavaConverters
zostały wycofane na korzyść scala.jdk.CollectionConverters
:
... nowy pakiet
scala.jdk
z obiektamiCollectionConverters
(klasycznych kolekcjach Java, podobnie jakcollection.JavaConverters
w 2.12)StreamConverters
,FunctionConverters
aOptionConverters
...
Jak wyjaśniono w interfejsie API, JavaConversions
jest to zestaw niejawnych konwersji, które przekształcają kolekcje Java w pokrewne kolekcje Scala.
Możesz go używać z import collection.JavaConversions._
. W razie potrzeby kompilator automatycznie przekształci kolekcję Java w odpowiedni typ Scala.
JavaConverters
to zestaw dekoratora, który pomaga przekształcać zbiory Java lub Scala Scala lub Java z wykorzystaniem zbiorów asScala
lub asJava
metod, które będą domyślnie dodawane do kolekcji, które chcesz przekształcić. Aby korzystać z tych konwerterów, musisz zaimportować:
import collection.JavaConverters._
Powinieneś preferować, JavaConversions
ponieważ generalnie jest łatwiejszy w użyciu (nie musisz używać asScala
lub asJava
).