Packages

•  package root

  This is the documentation for the Scala standard library.

  This is the documentation for the Scala standard library.

  Package structure

  The scala package contains core types like Int, Float, Array or Option which are accessible in all Scala compilation units without explicit qualification or imports.

  Notable packages include:

  • scala.collection and its sub-packages contain Scala's collections framework
    • scala.collection.immutable - Immutable, sequential data-structures such as Vector, List, Range, HashMap or HashSet
    • scala.collection.mutable - Mutable, sequential data-structures such as ArrayBuffer, StringBuilder, HashMap or HashSet
    • scala.collection.concurrent - Mutable, concurrent data-structures such as TrieMap
  • scala.concurrent - Primitives for concurrent programming such as Futures and Promises
  • scala.io - Input and output operations
  • scala.math - Basic math functions and additional numeric types like BigInt and BigDecimal
  • scala.sys - Interaction with other processes and the operating system
  • scala.util.matching - Regular expressions

  Other packages exist. See the complete list on the right.

  Additional parts of the standard library are shipped as separate libraries. These include:

  • scala.reflect - Scala's reflection API (scala-reflect.jar)
  • scala.xml - XML parsing, manipulation, and serialization (scala-xml.jar)
  • scala.collection.parallel - Parallel collections (scala-parallel-collections.jar)
  • scala.util.parsing - Parser combinators (scala-parser-combinators.jar)
  • scala.swing - A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)

  Automatic imports

  Identifiers in the scala package and the scala.Predef object are always in scope by default.

  Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example, List is an alias for scala.collection.immutable.List.

  Other aliases refer to classes provided by the underlying platform. For example, on the JVM, String is an alias for java.lang.String.

  Definition Classes

  root

•  package scala

  Core Scala types.

  Core Scala types. They are always available without an explicit import.

  Definition Classes

  root

•  package collection

  Definition Classes

  scala

•  object JavaConverters extends AsJavaConverters with AsScalaConverters

  A variety of decorators that enable converting between Scala and Java collections using extension methods, asScala and asJava.

  A variety of decorators that enable converting between Scala and Java collections using extension methods, asScala and asJava.

  The extension methods return adapters for the corresponding API.

  The following conversions are supported via asScala and asJava:

  scala.collection.Iterable       <=> java.lang.Iterable
  scala.collection.Iterator       <=> java.util.Iterator
  scala.collection.mutable.Buffer <=> java.util.List
  scala.collection.mutable.Set    <=> java.util.Set
  scala.collection.mutable.Map    <=> java.util.Map
  scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap

  The following conversions are supported via asScala and through specially-named extension methods to convert to Java collections, as shown:

  scala.collection.Iterable    <=> java.util.Collection   (via asJavaCollection)
  scala.collection.Iterator    <=> java.util.Enumeration  (via asJavaEnumeration)
  scala.collection.mutable.Map <=> java.util.Dictionary   (via asJavaDictionary)

  In addition, the following one-way conversions are provided via asJava:

  scala.collection.Seq         => java.util.List
  scala.collection.mutable.Seq => java.util.List
  scala.collection.Set         => java.util.Set
  scala.collection.Map         => java.util.Map

  The following one way conversion is provided via asScala:

  java.util.Properties => scala.collection.mutable.Map

  In all cases, converting from a source type to a target type and back again will return the original source object. For example:

  import scala.collection.JavaConverters._
  
  val source = new scala.collection.mutable.ListBuffer[Int]
  val target: java.util.List[Int] = source.asJava
  val other: scala.collection.mutable.Buffer[Int] = target.asScala
  assert(source eq other)

  Alternatively, the conversion methods have descriptive names and can be invoked explicitly.

  scala> val vs = java.util.Arrays.asList("hi", "bye")
  vs: java.util.List[String] = [hi, bye]
  
  scala> val ss = asScalaIterator(vs.iterator)
  ss: Iterator[String] = <iterator>
  
  scala> .toList
  res0: List[String] = List(hi, bye)
  
  scala> val ss = asScalaBuffer(vs)
  ss: scala.collection.mutable.Buffer[String] = Buffer(hi, bye)

  Definition Classes

  collection

  Annotations

  @deprecated

  Deprecated

  (Since version 2.13.0) Use scala.jdk.CollectionConverters instead

• AsJava
• AsJavaCollection
• AsJavaDictionary
• AsJavaEnumeration
• AsScala

scala.collection.JavaConverters

AsJavaEnumeration