Type Members

1.  abstract class AbstractBuffer[A] extends AbstractSeq[A] with Buffer[A]

   Explicit instantiation of the Buffer trait to reduce class file size in subclasses.

2.  abstract class AbstractIterable[A] extends collection.AbstractIterable[A] with Iterable[A]

   Explicit instantiation of the Iterable trait to reduce class file size in subclasses.

3.  abstract class AbstractMap[A, B] extends collection.AbstractMap[A, B] with Map[A, B]

   Explicit instantiation of the Map trait to reduce class file size in subclasses.

4.  abstract class AbstractSeq[A] extends collection.AbstractSeq[A] with Seq[A]

   Explicit instantiation of the Seq trait to reduce class file size in subclasses.

5.  abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A]

   Explicit instantiation of the Set trait to reduce class file size in subclasses.

6.  class AnyRefMap[K <: AnyRef, V] extends Map[K, V] with MapOps[K, V, Map, AnyRefMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, AnyRefMap[K, V]] with Serializable

   This class implements mutable maps with AnyRef keys based on a hash table with open addressing.

   This class implements mutable maps with AnyRef keys based on a hash table with open addressing.

   Basic map operations on single entries, including contains and get, are typically significantly faster with AnyRefMap than HashMap. Note that numbers and characters are not handled specially in AnyRefMap; only plain equals and hashCode are used in comparisons.

   Methods that traverse or regenerate the map, including foreach and map, are not in general faster than with HashMap. The methods foreachKey, foreachValue, mapValuesNow, and transformValues are, however, faster than alternative ways to achieve the same functionality.

   Maps with open addressing may become less efficient at lookup after repeated addition/removal of elements. Although AnyRefMap makes a decent attempt to remain efficient regardless, calling repack on a map that will no longer have elements removed but will be used heavily may save both time and storage space.

   This map is not intended to contain more than 2²⁹ entries (approximately 500 million). The maximum capacity is 2³⁰, but performance will degrade rapidly as 2³⁰ is approached.

   Annotations

   @SerialVersionUID()

7.  class ArrayBuffer[A] extends AbstractBuffer[A] with IndexedSeq[A] with IndexedSeqOps[A, ArrayBuffer, ArrayBuffer[A]] with IndexedOptimizedBuffer[A] with StrictOptimizedSeqOps[A, ArrayBuffer, ArrayBuffer[A]] with Serializable

   An implementation of the Buffer class using an array to represent the assembled sequence internally.

   An implementation of the Buffer class using an array to represent the assembled sequence internally. Append, update and random access take constant time (amortized time). Prepends and removes are linear in the buffer size.

   A

   the type of this arraybuffer's elements.

   Annotations

   @SerialVersionUID()

   Version

   2.8

   Since

   1

   See also

   "Scala's Collection Library overview" section on Array Buffers for more information.

8.  class ArrayBufferView[A] extends IndexedView[A]
9.  sealed abstract class ArrayBuilder[T] extends ReusableBuilder[T, Array[T]] with Serializable

   A builder class for arrays.

   A builder class for arrays.

   T

   the type of the elements for the builder.

   Since

   2.8

10.  class BitSet extends SortedSet[Int] with collection.BitSet with SortedSetOps[Int, SortedSet, BitSet] with BitSetOps[BitSet] with StrictOptimizedIterableOps[Int, Set, BitSet] with Serializable

    A class for mutable bitsets.

    A class for mutable bitsets.

    Bitsets are sets of non-negative integers which are represented as variable-size arrays of bits packed into 64-bit words. The memory footprint of a bitset is determined by the largest number stored in it.

    Annotations

    @SerialVersionUID()

    See also

    "Scala's Collection Library overview" section on Mutable Bitsets for more information.

11.  trait Buffer[A] extends Seq[A] with Growable[A] with Shrinkable[A]

    A Buffer is a growable and shrinkable Seq.

12.  trait Builder[-A, +To] extends Growable[A]

    Base trait for collection builders

13.  trait Clearable extends AnyRef

    This trait forms part of collections that can be cleared with a clear() call.

14.  trait Cloneable[+A <: AnyRef] extends scala.Cloneable

    A trait for cloneable collections.

    A trait for cloneable collections.

    A

    Type of the collection, covariant and with reference types as upperbound.

    Since

    2.8

15.  final class DefaultEntry[A, B] extends HashEntry[A, DefaultEntry[A, B]] with Serializable

    Class used internally for default map model.

    Class used internally for default map model.

    Since

    2.3

16.  trait Growable[-A] extends Clearable

    This trait forms part of collections that can be augmented using a += operator and that can be cleared of all elements using a clear method.

17.  class GrowableBuilder[Elem, To <: Growable[Elem]] extends Builder[Elem, To]

    The canonical builder for collections that are growable, i.e.

    The canonical builder for collections that are growable, i.e. that support an efficient += method which adds an element to the collection.

    GrowableBuilders can produce only a single instance of the collection they are growing.

    Version

    2.8

    Since

    2.8

18.  trait HashEntry[A, E <: HashEntry[A, E]] extends AnyRef

    Class used internally.

    Class used internally.

    Since

    2.8

19.  class HashMap[K, V] extends AbstractMap[K, V] with MapOps[K, V, HashMap, HashMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, HashMap[K, V]] with Serializable

    This class implements mutable maps using a hashtable.

    This class implements mutable maps using a hashtable.

    K

    the type of the keys contained in this hash map.

    V

    the type of the values assigned to keys in this hash map.

    Annotations

    @SerialVersionUID()

    Since

    1

    See also

    "Scala's Collection Library overview" section on Hash Tables for more information.

20.  final class HashSet[A] extends Set[A] with SetOps[A, HashSet, HashSet[A]] with StrictOptimizedIterableOps[A, HashSet, HashSet[A]] with Serializable

    This class implements mutable sets using a hashtable.

    This class implements mutable sets using a hashtable.

    Annotations

    @SerialVersionUID()

    Version

    2.0, 31/12/2006

    Since

    1

    See also

    "Scala's Collection Library overview" section on Hash Tables for more information.

21.  abstract class ImmutableBuilder[-A, C] extends ReusableBuilder[A, C]

    Reusable builder for immutable collections

22.  trait IndexedOptimizedBuffer[A] extends IndexedOptimizedSeq[A] with Buffer[A]
23.  trait IndexedOptimizedSeq[A] extends Seq[A]
24.  trait IndexedSeq[T] extends Seq[T] with collection.IndexedSeq[T] with IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]]
25.  trait IndexedSeqOps[A, +CC[X] <: IndexedSeq[X], +C <: IndexedSeq[A]] extends collection.IndexedSeqOps[A, CC, C] with SeqOps[A, CC, C]
26.  trait Iterable[A] extends collection.Iterable[A] with IterableOps[A, Iterable, Iterable[A]]
27.  trait IterableOps[A, +CC[X], +C] extends collection.IterableOps[A, CC, C]

28.  class LinkedHashMap[K, V] extends Map[K, V] with MapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, LinkedHashMap[K, V]] with Serializable

    This class implements mutable maps using a hashtable.

    This class implements mutable maps using a hashtable. The iterator and all traversal methods of this class visit elements in the order they were inserted.

    K

    the type of the keys contained in this hash map.

    V

    the type of the values assigned to keys in this hash map.

    Annotations

    @SerialVersionUID()

29.  class LinkedHashSet[A] extends Set[A] with SetOps[A, LinkedHashSet, LinkedHashSet[A]] with Serializable

    This class implements mutable sets using a hashtable.

    This class implements mutable sets using a hashtable. The iterator and all traversal methods of this class visit elements in the order they were inserted.

    A

    the type of the elements contained in this set.

    Annotations

    @SerialVersionUID()

    Version

    2.0, 31/12/2006

    Since

    1

30.  class ListBuffer[A] extends Buffer[A] with SeqOps[A, ListBuffer, ListBuffer[A]] with StrictOptimizedSeqOps[A, ListBuffer, ListBuffer[A]] with ReusableBuilder[A, List[A]] with Serializable

    A Buffer implementation backed by a list.

    A Buffer implementation backed by a list. It provides constant time prepend and append. Most other operations are linear.

    A

    the type of this list buffer's elements.

    Annotations

    @SerialVersionUID()

    Version

    2.8

    Since

    1

    See also

    "Scala's Collection Library overview" section on List Buffers for more information.

31.  final class LongMap[V] extends Map[Long, V] with MapOps[Long, V, Map, LongMap[V]] with StrictOptimizedIterableOps[(Long, V), Iterable, LongMap[V]] with Serializable

    This class implements mutable maps with Long keys based on a hash table with open addressing.

    This class implements mutable maps with Long keys based on a hash table with open addressing.

    Basic map operations on single entries, including contains and get, are typically substantially faster with LongMap than HashMap. Methods that act on the whole map, including foreach and map are not in general expected to be faster than with a generic map, save for those that take particular advantage of the internal structure of the map: foreachKey, foreachValue, mapValuesNow, and transformValues.

    Maps with open addressing may become less efficient at lookup after repeated addition/removal of elements. Although LongMap makes a decent attempt to remain efficient regardless, calling repack on a map that will no longer have elements removed but will be used heavily may save both time and storage space.

    This map is not intended to contain more than 2^{29 entries (approximately 500 million). The maximum capacity is 2}30, but performance will degrade rapidly as 2^30 is approached.

32.  trait Map[K, V] extends Iterable[(K, V)] with collection.Map[K, V] with MapOps[K, V, Map, Map[K, V]]

    Base type of mutable Maps

33.  trait MapOps[K, V, +CC[X, Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]] extends IterableOps[(K, V), Iterable, C] with collection.MapOps[K, V, CC, C] with Cloneable[C] with Growable[(K, V)] with Shrinkable[K]

34.  trait ReusableBuilder[-Elem, +To] extends Builder[Elem, To]

    ReusableBuilder is a marker trait that indicates that a Builder can be reused to build more than one instance of a collection.

    ReusableBuilder is a marker trait that indicates that a Builder can be reused to build more than one instance of a collection. In particular, calling result followed by clear will produce a collection and reset the builder to begin building a new collection of the same type.

    It is up to subclasses to implement this behavior, and to document any other behavior that varies from standard ReusableBuilder usage (e.g. operations being well-defined after a call to result, or allowing multiple calls to result to obtain different snapshots of a collection under construction).

    Elem

    the type of elements that get added to the builder.

    To

    the type of collection that it produced.

    Since

    2.12

35.  trait Seq[A] extends Iterable[A] with collection.Seq[A] with SeqOps[A, Seq, Seq[A]]
36.  trait SeqOps[A, +CC[X] <: Seq[X], +C <: Seq[A]] extends IterableOps[A, CC, C] with collection.SeqOps[A, CC, C] with Cloneable[C]

37.  trait Set[A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[A]]

    Base trait for mutable sets

38.  trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends IterableOps[A, CC, C] with collection.SetOps[A, CC, C] with Cloneable[C] with Growable[A] with Shrinkable[A]

39.  trait Shrinkable[-A] extends AnyRef

    This trait forms part of collections that can be reduced using a -= operator.

    This trait forms part of collections that can be reduced using a -= operator.

    Version

    2.8

    Since

    2.8

40.  trait SortedMap[K, V] extends collection.SortedMap[K, V] with Map[K, V] with SortedMapOps[K, V, SortedMap, SortedMap[K, V]]

    Base type for mutable sorted map collections

41.  trait SortedMapOps[K, V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends collection.SortedMapOps[K, V, CC, C] with MapOps[K, V, Map, C]
42.  trait SortedSet[A] extends Set[A] with collection.SortedSet[A] with SortedSetOps[A, SortedSet, SortedSet[A]]

    Base type for mutable sorted set collections

43.  trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] with collection.SortedSetOps[A, CC, C]

44.  class StringBuilder extends Builder[Char, String] with IndexedSeq[Char] with IndexedOptimizedSeq[Char] with Serializable
45.  sealed class TreeMap[K, V] extends SortedMap[K, V] with SortedMapOps[K, V, TreeMap, TreeMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, TreeMap[K, V]] with Serializable

    A mutable sorted map implemented using a mutable red-black tree as underlying data structure.

    A mutable sorted map implemented using a mutable red-black tree as underlying data structure.

    K

    the type of the keys contained in this tree map.

    V

    the type of the values associated with the keys.

    Annotations

    @SerialVersionUID()

    Version

    2.12

    Since

    2.12

46.  sealed class TreeSet[A] extends SortedSet[A] with SortedSetOps[A, TreeSet, TreeSet[A]] with StrictOptimizedIterableOps[A, Set, TreeSet[A]] with StrictOptimizedSortedSetOps[A, TreeSet, TreeSet[A]] with Serializable

    A mutable sorted set implemented using a mutable red-black tree as underlying data structure.

    A mutable sorted set implemented using a mutable red-black tree as underlying data structure.

    A

    the type of the keys contained in this tree set.

    Annotations

    @SerialVersionUID()

    Version

    2.12

    Since

    2.10

47.  class WeakHashMap[A, B] extends convert.Wrappers.JMapWrapper[A, B] with convert.Wrappers.JMapWrapperLike[A, B, WeakHashMap[A, B]]

    A hash map with references to entries which are weakly reachable.

    A hash map with references to entries which are weakly reachable. Entries are removed from this map when the key is no longer (strongly) referenced. This class wraps java.util.WeakHashMap.

    A

    type of keys contained in this map

    B

    type of values associated with the keys

    Since

    2.8

    See also

    "Scala's Collection Library overview" section on Weak Hash Maps for more information.

48.  abstract class WrappedArray[T] extends AbstractSeq[T] with IndexedSeq[T] with IndexedSeqOps[T, WrappedArray, WrappedArray[T]] with ArrayLike[T] with IndexedOptimizedSeq[T] with StrictOptimizedSeqOps[T, WrappedArray, WrappedArray[T]] with Serializable

    A collection representing Array[T].

    A collection representing Array[T]. Unlike ArrayBuffer it is always backed by the same underlying Array, therefore it is not growable or shrinkable.

    T

    type of the elements in this wrapped array.

    Version

    1.0

    Since

    2.8

49.  type ArraySeq[X] = WrappedArray[X]

    Annotations

    @deprecated

    Deprecated

    (Since version 2.13.0) Use WrappedArray instead of ArraySeq

50.  type LinearSeq[X] = Seq[X] with collection.LinearSeq[X]

    Annotations

    @deprecated

    Deprecated

    (Since version 2.13.0) mutable.LinearSeq has been removed; use LinearSeq with mutable.Seq instead

51.  type Traversable[X] = Iterable[X]

    Annotations

    @deprecated

    Deprecated

    (Since version 2.13.0) Use Iterable instead of Traversable