Add code tabs for collections-2.13/conversions

_overviews/collections-2.13/conversions-between-java-and-scala-collections.md

@@ -16,7 +16,6 @@ Like Scala, Java also has a rich collections library. There are many similaritie
 
 Sometimes you might need to pass from one collection framework to the other. For instance, you might want to access an existing Java collection as if it were a Scala collection. Or you might want to pass one of Scala's collections to a Java method that expects its Java counterpart. It is quite easy to do this, because Scala offers implicit conversions between all the major collection types in the [CollectionConverters](https://www.scala-lang.org/api/{{ site.scala-version }}/scala/jdk/CollectionConverters$.html) object. In particular, you will find bidirectional conversions between the following types.
 
-
     Iterator               <=>     java.util.Iterator
     Iterator               <=>     java.util.Enumeration
     Iterable               <=>     java.lang.Iterable
@@ -28,11 +27,20 @@ Sometimes you might need to pass from one collection framework to the other. For
 
 To enable these conversions, simply import them from the [CollectionConverters](https://www.scala-lang.org/api/{{ site.scala-version }}/scala/jdk/CollectionConverters$.html) object:
 
+{% tabs java_scala_1 %}
+{% tab 'Scala 2 and 3' for=java_scala_1 %}
+
     scala> import scala.jdk.CollectionConverters._
     import scala.jdk.CollectionConverters._
 
+{% endtab %}
+{% endtabs %}
+
 This enables conversions between Scala collections and their corresponding Java collections by way of extension methods called `asScala` and `asJava`:
 
+{% tabs java_scala_2 %}
+{% tab 'Scala 2 and 3' for=java_scala_2 %}
+
     scala> import collection.mutable._
     import collection.mutable._
 
@@ -45,6 +53,9 @@ This enables conversions between Scala collections and their corresponding Java
     scala> val m: java.util.Map[String, Int] = HashMap("abc" -> 1, "hello" -> 2).asJava
     m: java.util.Map[String,Int] = {abc=1, hello=2}
 
+{% endtab %}
+{% endtabs %}
+
 Internally, these conversion work by setting up a "wrapper" object that forwards all operations to the underlying collection object. So collections are never copied when converting between Java and Scala. An interesting property is that if you do a round-trip conversion from, say a Java type to its corresponding Scala type, and back to the same Java type, you end up with the identical collection object you have started with.
 
 Certain other Scala collections can also be converted to Java, but do not have a conversion back to the original Scala type:
@@ -56,9 +67,15 @@ Certain other Scala collections can also be converted to Java, but do not have a
 
 Because Java does not distinguish between mutable and immutable collections in their type, a conversion from, say, `scala.immutable.List` will yield a `java.util.List`, where all mutation operations throw an "UnsupportedOperationException". Here's an example:
 
+{% tabs java_scala_3 %}
+{% tab 'Scala 2 and 3' for=java_scala_3 %}
+
     scala> val jul = List(1, 2, 3).asJava
     jul: java.util.List[Int] = [1, 2, 3]
 
     scala> jul.add(7)
     java.lang.UnsupportedOperationException
       at java.util.AbstractList.add(AbstractList.java:148)
+
+{% endtab %}
+{% endtabs %}