In scala.collection, ci sono due oggetti molto simili JavaConversionse JavaConverters.
- Qual è la differenza tra questi due oggetti?
- Perché esistono entrambi?
- Quando voglio usare l'uno contro l'altro?
In scala.collection, ci sono due oggetti molto simili JavaConversionse JavaConverters.
Risposte:
EDIT: Java Conversionsottenuto @deprecatedin Scala 2.13.0. Utilizzare invece scala.jdk.CollectionConverters .
JavaConversionsfornire una serie di metodi impliciti che convertono tra una raccolta Java e la raccolta Scala corrispondente più vicina e viceversa. Questo viene fatto creando involucri che implementano l'interfaccia Scala e inoltrano le chiamate alla raccolta Java sottostante o l'interfaccia Java, inoltrando le chiamate alla raccolta Scala sottostante.
JavaConvertersusa il modello pimp-my-library per "aggiungere" il asScalametodo alle raccolte Java e il asJavametodo alle raccolte Scala, che restituiscono i wrapper appropriati discussi sopra. È più recente (dalla versione 2.8.1) rispetto a JavaConversions(dalla 2.8) e rende esplicita la conversione tra la raccolta Scala e Java. Contrariamente a quanto scrive David nella sua risposta, ti consiglio di prendere l'abitudine di usarlo JavaConverterspoiché avrai molte meno probabilità di scrivere codice che crea molte conversioni implicite, in quanto puoi controllare l'unico punto in cui ciò accadrà : dove scrivi .asScalao .asJava.
Ecco i metodi di conversione che JavaConvertersforniscono:
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]
Per utilizzare le conversioni direttamente da Java, tuttavia, è meglio chiamare JavaConversionsdirettamente i metodi ; per esempio:
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
JavaConversionssiano utili, potresti trascurare rapidamente tutti i luoghi in cui possono essere inserite dal compilatore. Tu controlli quei posti con JavaConverters. È l'intera discussione sulla conversione implicita vs esplicita.
import JavaConversions._, le conversioni non si verificheranno in modo da avere il controllo su ciò che viene convertito. Se si posiziona l'importazione nel modo giusto (solo quando necessario), si ha il pieno controllo su dove viene eseguita la conversione.
JavaConverterste hai la sicurezza aggiuntiva che non succede nulla se non lo scrivi esplicitamente. Questa è una sicurezza aggiuntiva ed è probabilmente il motivo per cui questa classe è stata aggiunta.
Per chiunque atterri su questa domanda a partire da Scala 2.12.x, JavaConversionsè ora obsoleto ed JavaConvertersè il metodo preferito.
JavaConvertersè deprecato, ed scala.jdk.CollectionConvertersè il metodo preferito;)
In Scala 2.13, JavaConverterssono stati deprecati a favore di scala.jdk.CollectionConverters:
... nuovo pacchetto
scala.jdkcon oggettiCollectionConverters(raccolte Java classiche, simili acollection.JavaConvertersin 2.12)StreamConverters,FunctionConverterseOptionConverters...
Come spiegato nell'API, JavaConversionsè un insieme di conversioni implicite che trasforma le raccolte java in raccolte scala correlate.
Puoi usarlo con un import collection.JavaConversions._. Se necessario, il compilatore trasformerà automaticamente la raccolta java nel giusto tipo di scala.
JavaConverterssono un insieme di decoratrice che aiuta a trasformare le collezioni di Java o Scala a collezioni Scala o Java che utilizzano asScalao asJavametodi che saranno implicitamente aggiunti alla collezione che si desidera trasformare. Per utilizzare questi convertitori, è necessario importare:
import collection.JavaConverters._Dovresti preferire in JavaConversionsquanto è generalmente più facile da usare (non è necessario utilizzare asScalao asJava).