Dans scala.collection, il y a deux objets très similaires JavaConversionset JavaConverters.
- Quelle est la différence entre ces deux objets?
- Pourquoi existent-ils tous les deux?
- Quand dois-je utiliser l'un contre l'autre?
Dans scala.collection, il y a deux objets très similaires JavaConversionset JavaConverters.
Réponses:
EDIT: Java Conversionsentré @deprecateddans Scala 2.13.0. Utilisez plutôt scala.jdk.CollectionConverters .
JavaConversionsfournir une série de méthodes implicites qui convertissent entre une collection Java et la collection Scala correspondante la plus proche, et vice versa. Pour ce faire, créez des wrappers qui implémentent soit l'interface Scala et transfèrent les appels vers la collection Java sous-jacente, soit l'interface Java, en transférant les appels vers la collection Scala sous-jacente.
JavaConvertersutilise le modèle pimp-my-library pour «ajouter» la asScalaméthode aux collections Java et la asJavaméthode aux collections Scala, qui renvoient les wrappers appropriés décrits ci-dessus. Il est plus récent (depuis la version 2.8.1) que JavaConversions(depuis la 2.8) et rend explicite la conversion entre Scala et la collection Java. Contrairement à ce que David écrit dans sa réponse, je vous recommande de prendre l'habitude d'utiliser JavaConverterscar vous serez beaucoup moins susceptible d'écrire du code qui fait beaucoup de conversions implicites, car vous pouvez contrôler le seul endroit où cela se produira. : où vous écrivez .asScalaou .asJava.
Voici les méthodes de conversion qui JavaConvertersfournissent:
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]Cependant, pour utiliser les conversions directement à partir de Java, il vaut mieux appeler JavaConversionsdirectement les méthodes ; par exemple:
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); // trueJavaConversionssoient pratiques, vous pouvez rapidement ignorer tous les endroits où elles peuvent être insérées par le compilateur. Vous contrôlez ces endroits avec JavaConverters. C'est toute la discussion sur la conversion implicite vs explicite.
import JavaConversions._, les conversions ne se produiront pas, vous avez donc le contrôle sur ce qui est converti. Si vous placez l'importation dans le bon sens (uniquement lorsque cela est nécessaire), vous avez un contrôle total sur l'endroit où la conversion est effectuée.
JavaConvertersvous avez la sécurité supplémentaire que rien ne se passe à moins que vous ne l' écriviez explicitement. C'est une sécurité supplémentaire, et c'est probablement pourquoi cette classe a été ajoutée.
Pour quiconque atterrit sur cette question depuis Scala 2.12.x, JavaConversionsest désormais obsolète et JavaConvertersest la méthode préférée.
JavaConvertersest obsolète et scala.jdk.CollectionConvertersest la méthode préférée;)
Dans Scala 2.13, JavaConvertersont été dépréciés au profit de scala.jdk.CollectionConverters:
... nouveau package
scala.jdkavec des objetsCollectionConverters(collections Java classiques, similaires àcollection.JavaConverters2.12)StreamConverters,FunctionConvertersetOptionConverters...
Comme expliqué dans l'API, JavaConversionsest un ensemble de conversions implicites qui transforme les collections java en collection scala associée.
Vous pouvez l'utiliser avec un import collection.JavaConversions._. Si nécessaire, le compilateur transformera automatiquement la collection java en le bon type de scala.
JavaConverterssont un ensemble de décorateur qui aide à transformer les collections java ou scala en collections scala ou java en utilisant des méthodes asScalaou asJavaqui seront implicitement ajoutées à la collection que vous souhaitez transformer. Pour utiliser ces convertisseurs, vous devez importer:
import collection.JavaConverters._Vous devriez préférer JavaConversionscar il est généralement plus facile à utiliser (pas besoin d'utiliser asScalaou asJava).