What is the difference between JavaConverters and JavaConversions in Scala?

by

EDIT: Java Conversions got @deprecated in Scala 2.13.0. Use scala.jdk.CollectionConverters instead.

JavaConversions provide a series of implicit methods that convert between a Java collection and the closest corresponding Scala collection, and vice versa. This is done by creating wrappers that implement either the Scala interface and forward the calls to the underlying Java collection, or the Java interface, forwarding the calls to the underlying Scala collection.

JavaConverters uses the pimp-my-library pattern to “add” the asScala method to the Java collections and the asJava method to the Scala collections, which return the appropriate wrappers discussed above. It is newer (since version 2.8.1) than JavaConversions (since 2.8) and makes the conversion between Scala and Java collection explicit. Contrary to what David writes in his answer, I’d recommend you make it a habit to use JavaConverters as you’ll be much less likely to write code that makes a lot of implicit conversions, as you can control the only spot where that will happen: where you write .asScala or .asJava.

Here’s the conversion methods that JavaConverters provide:

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]

To use the conversions directly from Java, though, you’re better off calling methods from JavaConversions directly; e.g.:

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

More Related Contents:

  1. Scala 2.8 breakOut
  2. Is the Scala 2.8 collections library a case of “the longest suicide note in history”? [closed]
  3. Why is Scala’s immutable Set not covariant in its type?
  4. When should I choose Vector in Scala?
  5. What does param: _* mean in Scala?
  6. Scala 2.8 collections design tutorial
  7. What’s the difference between == and .equals in Scala?
  8. withFilter instead of filter
  9. What type to use to store an in-memory mutable data table in Scala?
  10. Scala Map implementation keeping entries in insertion order?
  11. Stream vs Views vs Iterators
  12. How to read files from resources folder in Scala?
  13. Function returns an empty List in Spark
  14. Scala: Why does Seq.contains take an Any argument, instead of an argument of the sequence type?
  15. Reduce, fold or scan (Left/Right)?
  16. Scala Sets contain the same elements, but sameElements() returns false
  17. Convert Java Map to Scala Map
  18. Difference between MutableList and ListBuffer
  19. Scala: Parallel collection in object initializer causes a program to hang
  20. Scala best way of turning a Collection into a Map-by-key?
  21. scala parallel collections degree of parallelism
  22. How can I change column types in Spark SQL’s DataFrame?
  23. Case class to map in Scala
  24. What does => and () => mean in Scala [duplicate]
  25. Load Scala file into interpreter to use functions?
  26. Any reason why scala does not explicitly support dependent types?
  27. Apache Spark, add an “CASE WHEN … ELSE …” calculated column to an existing DataFrame
  28. Scala: pass Seq to var-args functions
  29. Why does Scala support shadow variables? [closed]
  30. How to split a sequence into two pieces by predicate?

Leave a Comment