package mutable
- Alphabetic
- By Inheritance
- mutable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- abstract class AbstractBuffer[A] extends AbstractSeq[A] with Buffer[A]
Explicit instantiation of the
Buffer
trait to reduce class file size in subclasses.Explicit instantiation of the
Buffer
trait to reduce class file size in subclasses.- Annotations
- @SerialVersionUID()
- abstract class AbstractIterable[A] extends collection.AbstractIterable[A] with Iterable[A]
Explicit instantiation of the
Iterable
trait to reduce class file size in subclasses.Explicit instantiation of the
Iterable
trait to reduce class file size in subclasses.- Annotations
- @SerialVersionUID()
- abstract class AbstractMap[K, V] extends collection.AbstractMap[K, V] with Map[K, V]
Explicit instantiation of the
Map
trait to reduce class file size in subclasses.Explicit instantiation of the
Map
trait to reduce class file size in subclasses.- Annotations
- @SerialVersionUID()
- abstract class AbstractSeq[A] extends collection.AbstractSeq[A] with Seq[A]
Explicit instantiation of the
Seq
trait to reduce class file size in subclasses.Explicit instantiation of the
Seq
trait to reduce class file size in subclasses.- Annotations
- @SerialVersionUID()
- abstract class AbstractSet[A] extends collection.AbstractSet[A] with Set[A]
Explicit instantiation of the
Set
trait to reduce class file size in subclasses.Explicit instantiation of the
Set
trait to reduce class file size in subclasses.- Annotations
- @SerialVersionUID()
- class AnyRefMap[K <: AnyRef, V] extends AbstractMap[K, V] with MapOps[K, V, Map, AnyRefMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, AnyRefMap[K, V]]
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
andget
, are typically significantly faster withAnyRefMap
than HashMap. Note that numbers and characters are not handled specially in AnyRefMap; only plainequals
andhashCode
are used in comparisons.Methods that traverse or regenerate the map, including
foreach
andmap
, are not in general faster than withHashMap
. The methodsforeachKey
,foreachValue
,mapValuesNow
, andtransformValues
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, callingrepack
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 229 entries (approximately 500 million). The maximum capacity is 230, but performance will degrade rapidly as 230 is approached.
- class ArrayBuffer[A] extends AbstractBuffer[A] with IndexedBuffer[A] with IndexedSeqOps[A, ArrayBuffer, ArrayBuffer[A]] with StrictOptimizedSeqOps[A, ArrayBuffer, ArrayBuffer[A]]
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.
- Since
1
- See also
"Scala's Collection Library overview" section on
Array Buffers
for more information.
- final class ArrayBufferView[A] extends AbstractIndexedSeqView[A]
- 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.
- Annotations
- @SerialVersionUID()
- Since
2.8
- class ArrayDeque[A] extends AbstractBuffer[A] with IndexedBuffer[A] with IndexedSeqOps[A, ArrayDeque, ArrayDeque[A]] with StrictOptimizedSeqOps[A, ArrayDeque, ArrayDeque[A]]
An implementation of a double-ended queue that internally uses a resizable circular buffer Append, prepend, removeFirst, removeLast and random-access (indexed-lookup and indexed-replacement) take amortized constant time.
An implementation of a double-ended queue that internally uses a resizable circular buffer Append, prepend, removeFirst, removeLast and random-access (indexed-lookup and indexed-replacement) take amortized constant time. In general, removals and insertions at i-th index are O(min(i, n-i)) and thus insertions and removals from end/beginning are fast.
- A
the type of this ArrayDeque's elements.
- Since
2.13
- Note
Subclasses must override the
ofArray
protected method to return a more specific type.
- sealed abstract class ArraySeq[T] extends AbstractSeq[T] with IndexedSeq[T] with IndexedSeqOps[T, ArraySeq, ArraySeq[T]] with StrictOptimizedSeqOps[T, ArraySeq, ArraySeq[T]]
A collection representing
Array[T]
.A collection representing
Array[T]
. UnlikeArrayBuffer
it is always backed by the same underlyingArray
, therefore it is not growable or shrinkable.- T
type of the elements in this wrapped array.
- Annotations
- @SerialVersionUID()
- Since
2.8
- class BitSet extends AbstractSet[Int] with SortedSet[Int] with collection.BitSet with SortedSetOps[Int, SortedSet, BitSet] with BitSetOps[BitSet] with StrictOptimizedIterableOps[Int, Set, BitSet] with StrictOptimizedSortedSetOps[Int, SortedSet, BitSet]
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.
- See also
"Scala's Collection Library overview" section on
Mutable Bitsets
for more information.
- trait Buffer[A] extends Seq[A] with SeqOps[A, Buffer, Buffer[A]] with Growable[A] with Shrinkable[A]
A
Buffer
is a growable and shrinkableSeq
. - trait Builder[-A, +To] extends Growable[A]
Base trait for collection builders
- trait Clearable extends AnyRef
This trait forms part of collections that can be cleared with a clear() call.
- trait Cloneable[+C <: AnyRef] extends scala.Cloneable
A trait for cloneable collections.
A trait for cloneable collections.
- C
Type of the collection, covariant and with reference types as upperbound.
- Since
2.8
- 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 aclear
method. - 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.
- Since
2.8
- 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 StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]]
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.
- Since
1
- See also
"Scala's Collection Library overview" section on
Hash Tables
for more information.
- final class HashSet[A] extends AbstractSet[A] with SetOps[A, HashSet, HashSet[A]] with StrictOptimizedIterableOps[A, HashSet, HashSet[A]]
This class implements mutable sets using a hashtable.
This class implements mutable sets using a hashtable.
- Since
1
- See also
"Scala's Collection Library overview" section on
Hash Tables
for more information.
- abstract class ImmutableBuilder[-A, C] extends ReusableBuilder[A, C]
Reusable builder for immutable collections
- trait IndexedBuffer[A] extends IndexedSeq[A] with IndexedSeqOps[A, IndexedBuffer, IndexedBuffer[A]] with Buffer[A]
- trait IndexedSeq[T] extends Seq[T] with collection.IndexedSeq[T] with IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]]
- trait IndexedSeqOps[A, +CC[_], +C <: AnyRef] extends collection.IndexedSeqOps[A, CC, C] with SeqOps[A, CC, C]
- trait Iterable[A] extends collection.Iterable[A] with IterableOps[A, Iterable, Iterable[A]]
- class LinkedHashMap[K, V] extends AbstractMap[K, V] with SeqMap[K, V] with MapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, LinkedHashMap[K, V]] with StrictOptimizedMapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]]
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.
- class LinkedHashSet[A] extends AbstractSet[A] with SetOps[A, LinkedHashSet, LinkedHashSet[A]] with StrictOptimizedIterableOps[A, LinkedHashSet, LinkedHashSet[A]]
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.
- Since
1
- class ListBuffer[A] extends AbstractBuffer[A] with SeqOps[A, ListBuffer, ListBuffer[A]] with StrictOptimizedSeqOps[A, ListBuffer, ListBuffer[A]] with ReusableBuilder[A, immutable.List[A]]
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.
- Since
1
- See also
"Scala's Collection Library overview" section on
List Buffers
for more information.
- final class LongMap[V] extends AbstractMap[Long, V] with MapOps[Long, V, Map, LongMap[V]] with StrictOptimizedIterableOps[(Long, V), Iterable, LongMap[V]]
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
andget
, are typically substantially faster withLongMap
than HashMap. Methods that act on the whole map, includingforeach
andmap
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
, andtransformValues
.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, callingrepack
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 229 entries (approximately 500 million). The maximum capacity is 230, but performance will degrade rapidly as 2^30 is approached.
- trait Map[K, V] extends Iterable[(K, V)] with collection.Map[K, V] with MapOps[K, V, Map, Map[K, V]] with Growable[(K, V)] with Shrinkable[K]
Base type of mutable Maps
- 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 Builder[(K, V), C] with Growable[(K, V)] with Shrinkable[K]
- trait MultiMap[A, B] extends Map[A, Set[B]]
A trait for mutable maps with multiple values assigned to a key.
A trait for mutable maps with multiple values assigned to a key.
This class is typically used as a mixin. It turns maps which map
A
toSet[B]
objects into multimaps that mapA
toB
objects.// first import all necessary types from package `collection.mutable` import collection.mutable.{ HashMap, MultiMap, Set } // to create a `MultiMap` the easiest way is to mixin it into a normal // `Map` instance val mm = new HashMap[Int, Set[String]] with MultiMap[Int, String] // to add key-value pairs to a multimap it is important to use // the method `addBinding` because standard methods like `+` will // overwrite the complete key-value pair instead of adding the // value to the existing key mm.addBinding(1, "a") mm.addBinding(2, "b") mm.addBinding(1, "c") // mm now contains `Map(2 -> Set(b), 1 -> Set(c, a))` // to check if the multimap contains a value there is method // `entryExists`, which allows to traverse the including set mm.entryExists(1, _ == "a") == true mm.entryExists(1, _ == "b") == false mm.entryExists(2, _ == "b") == true // to remove a previous added value there is the method `removeBinding` mm.removeBinding(1, "a") mm.entryExists(1, _ == "a") == false
Example: - sealed class PriorityQueue[A] extends AbstractIterable[A] with Iterable[A] with IterableOps[A, Iterable, PriorityQueue[A]] with StrictOptimizedIterableOps[A, Iterable, PriorityQueue[A]] with Builder[A, PriorityQueue[A]] with Cloneable[PriorityQueue[A]] with Growable[A]
This class implements priority queues using a heap.
This class implements priority queues using a heap. To prioritize elements of type A there must be an implicit Ordering[A] available at creation.
Only the
dequeue
anddequeueAll
methods will return elements in priority order (while removing elements from the heap). Standard collection methods includingdrop
,iterator
, andtoString
will remove or traverse the heap in whichever order seems most convenient.Therefore, printing a
PriorityQueue
will not reveal the priority order of the elements, though the highest-priority element will be printed first. To print the elements in order, one must duplicate thePriorityQueue
(by usingclone
, for instance) and then dequeue them:- A
type of the elements in this priority queue.
val pq = collection.mutable.PriorityQueue(1, 2, 5, 3, 7) println(pq) // elements probably not in order println(pq.clone.dequeueAll) // prints ArraySeq(7, 5, 3, 2, 1)
- Since
1
Example: - class Queue[A] extends ArrayDeque[A] with IndexedSeqOps[A, Queue, Queue[A]] with StrictOptimizedSeqOps[A, Queue, Queue[A]] with Cloneable[Queue[A]]
Queue
objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.Queue
objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.- Since
2.13
- trait ReusableBuilder[-Elem, +To] extends Builder[Elem, To]
ReusableBuilder
is a marker trait that indicates that aBuilder
can be reused to build more than one instance of a collection.ReusableBuilder
is a marker trait that indicates that aBuilder
can be reused to build more than one instance of a collection. In particular, callingresult
followed byclear
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 toresult
, 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
- trait Seq[A] extends Iterable[A] with collection.Seq[A] with SeqOps[A, Seq, Seq[A]]
- trait SeqMap[K, V] extends AbstractMap[K, V] with MapOps[K, V, SeqMap, SeqMap[K, V]]
A generic trait for ordered mutable maps.
A generic trait for ordered mutable maps. Concrete classes have to provide functionality for the abstract methods in
SeqMap
.Note that when checking for equality SeqMap does not take into account ordering.
- K
the type of the keys contained in this linked map.
- V
the type of the values associated with the keys in this linked map.
- Version
2.13
- Since
2.13
- trait SeqOps[A, +CC[_], +C <: AnyRef] extends collection.SeqOps[A, CC, C] with Cloneable[C]
- trait Set[A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[A]]
Base trait for mutable sets
- trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends collection.SetOps[A, CC, C] with Cloneable[C] with Builder[A, C] with Growable[A] with Shrinkable[A]
- 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.- Since
2.8
- 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
- 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]
- trait SortedSet[A] extends Set[A] with collection.SortedSet[A] with SortedSetOps[A, SortedSet, SortedSet[A]]
Base type for mutable sorted set collections
- trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] with collection.SortedSetOps[A, CC, C]
- class Stack[A] extends ArrayDeque[A] with IndexedSeqOps[A, Stack, Stack[A]] with StrictOptimizedSeqOps[A, Stack, Stack[A]] with Cloneable[Stack[A]]
A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.
- A
type of the elements contained in this stack.
- Annotations
- @migration
- Migration
(Changed in version 2.13.0) Stack is now based on an ArrayDeque instead of a linked list
- Since
2.13
- final class StringBuilder extends AbstractSeq[Char] with Builder[Char, String] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, StringBuilder] with CharSequence
A builder for mutable sequence of characters.
A builder for mutable sequence of characters. This class provides an API mostly compatible with
java.lang.StringBuilder
, except where there are conflicts with the Scala collections API (such as thereverse
method.)- Annotations
- @SerialVersionUID()
- Since
2.7
- sealed class TreeMap[K, V] extends AbstractMap[K, V] with SortedMap[K, V] with SortedMapOps[K, V, TreeMap, TreeMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, TreeMap[K, V]] with StrictOptimizedMapOps[K, V, Map, TreeMap[K, V]] with StrictOptimizedSortedMapOps[K, V, TreeMap, TreeMap[K, V]]
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.
- Since
2.12
- sealed class TreeSet[A] extends AbstractSet[A] with SortedSet[A] with SortedSetOps[A, TreeSet, TreeSet[A]] with StrictOptimizedIterableOps[A, Set, TreeSet[A]] with StrictOptimizedSortedSetOps[A, TreeSet, TreeSet[A]]
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.
- Since
2.10
- sealed class UnrolledBuffer[T] extends AbstractBuffer[T] with Buffer[T] with Seq[T] with SeqOps[T, UnrolledBuffer, UnrolledBuffer[T]] with StrictOptimizedSeqOps[T, UnrolledBuffer, UnrolledBuffer[T]] with Builder[T, UnrolledBuffer[T]]
A buffer that stores elements in an unrolled linked list.
A buffer that stores elements in an unrolled linked list.
Unrolled linked lists store elements in linked fixed size arrays.
Unrolled buffers retain locality and low memory overhead properties of array buffers, but offer much more efficient element addition, since they never reallocate and copy the internal array.
However, they provide
O(n/m)
complexity random access, wheren
is the number of elements, andm
the size of internal array chunks.Ideal to use when:
- elements are added to the buffer and then all of the elements are traversed sequentially
- two unrolled buffers need to be concatenated (see
concat
)
Better than singly linked lists for random access, but should still be avoided for such a purpose.
- class WeakHashMap[A, B] extends convert.Wrappers.JMapWrapper[A, B] with convert.Wrappers.JMapWrapperLike[A, B, WeakHashMap, 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.
- type ArrayStack[X] = Stack[X]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Stack instead of ArrayStack; it now uses an array-based implementation
- type GrowingBuilder[Elem, To <: Growable[Elem]] = GrowableBuilder[Elem, To]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) GrowingBuilder has been renamed to GrowableBuilder
- type IndexedOptimizedBuffer[A] = IndexedBuffer[A]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) IndexedOptimizedBuffer has been renamed to IndexedBuffer
- type IndexedOptimizedSeq[A] = IndexedSeq[A]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) IndexedOptimizedSeq has been renamed to IndexedSeq
- 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
- class ListMap[K, V] extends AbstractMap[K, V] with MapOps[K, V, ListMap, ListMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, ListMap[K, V]] with StrictOptimizedMapOps[K, V, ListMap, ListMap[K, V]]
A simple mutable map backed by a list, so it preserves insertion order.
A simple mutable map backed by a list, so it preserves insertion order.
- K
the type of the keys contained in this list map.
- V
the type of the values assigned to keys in this list map.
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use an immutable.ListMap assigned to a var instead of mutable.ListMap
- class OpenHashMap[Key, Value] extends AbstractMap[Key, Value] with MapOps[Key, Value, OpenHashMap, OpenHashMap[Key, Value]] with StrictOptimizedIterableOps[(Key, Value), Iterable, OpenHashMap[Key, Value]]
A mutable hash map based on an open hashing scheme.
A mutable hash map based on an open hashing scheme. The precise scheme is undefined, but it should make a reasonable effort to ensure that an insert with consecutive hash codes is not unnecessarily penalised. In particular, mappings of consecutive integer keys should work without significant performance loss.
- Key
type of the keys in this map.
- Value
type of the values in this map.
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap
- Since
2.7
- type Traversable[X] = Iterable[X]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Iterable instead of Traversable
- type WrappedArray[X] = ArraySeq[X]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays
Value Members
- object AnyRefMap extends Serializable
- object ArrayBuffer extends StrictOptimizedSeqFactory[ArrayBuffer]
Factory object for the
ArrayBuffer
class.Factory object for the
ArrayBuffer
class.This object provides a set of operations to create
mutable.ArrayBuffer
values.- Annotations
- @SerialVersionUID()
- object ArrayBuilder extends Serializable
A companion object for array builders.
A companion object for array builders.
- Since
2.8
- object ArrayDeque extends StrictOptimizedSeqFactory[ArrayDeque]
This object provides a set of operations to create
ArrayDeque
values.This object provides a set of operations to create
ArrayDeque
values.- Annotations
- @SerialVersionUID()
- object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq]
A companion object used to create instances of
ArraySeq
.A companion object used to create instances of
ArraySeq
.- Annotations
- @SerialVersionUID()
- object BitSet extends SpecificIterableFactory[Int, BitSet] with Serializable
- Annotations
- @SerialVersionUID()
- object Buffer extends Delegate[Buffer]
- Annotations
- @SerialVersionUID()
- object Growable
- object HashMap extends MapFactory[HashMap]
This object provides a set of operations to create
mutable.HashMap
values.This object provides a set of operations to create
mutable.HashMap
values.- Annotations
- @SerialVersionUID()
- object HashSet extends IterableFactory[HashSet]
This object provides a set of operations to create
mutable.HashSet
values.This object provides a set of operations to create
mutable.HashSet
values.- Annotations
- @SerialVersionUID()
- object IndexedBuffer extends Delegate[IndexedBuffer]
- Annotations
- @SerialVersionUID()
- object IndexedSeq extends Delegate[IndexedSeq]
- Annotations
- @SerialVersionUID()
- object Iterable extends Delegate[Iterable]
This object provides a set of operations to create
mutable.Iterable
values.This object provides a set of operations to create
mutable.Iterable
values.- Annotations
- @SerialVersionUID()
- object LinkedHashMap extends MapFactory[LinkedHashMap]
This object provides a set of operations to create
LinkedHashMap
values.This object provides a set of operations to create
LinkedHashMap
values.- Annotations
- @SerialVersionUID()
- object LinkedHashSet extends IterableFactory[LinkedHashSet]
This object provides a set of operations to create
LinkedHashSet
values.This object provides a set of operations to create
LinkedHashSet
values.- Annotations
- @SerialVersionUID()
- object ListBuffer extends StrictOptimizedSeqFactory[ListBuffer]
- Annotations
- @SerialVersionUID()
- object LongMap extends Serializable
- object Map extends Delegate[Map]
This object provides a set of operations to create
mutable.Map
values.This object provides a set of operations to create
mutable.Map
values.- Annotations
- @SerialVersionUID()
- object PriorityQueue extends SortedIterableFactory[PriorityQueue]
- Annotations
- @SerialVersionUID()
- object Queue extends StrictOptimizedSeqFactory[Queue]
This object provides a set of operations to create
Queue
values.This object provides a set of operations to create
Queue
values.- Annotations
- @SerialVersionUID()
- object RefArrayUtils
An object used internally by collections backed by an extensible Array[AnyRef]
- object Seq extends Delegate[Seq]
This object provides a set of operations to create
mutable.Seq
values.This object provides a set of operations to create
mutable.Seq
values.- Annotations
- @SerialVersionUID()
- object SeqMap extends Delegate[SeqMap]
- object Set extends Delegate[Set]
This object provides a set of operations to create
mutable.Set
values.This object provides a set of operations to create
mutable.Set
values.- Annotations
- @SerialVersionUID()
- object SortedMap extends Delegate[SortedMap]
- Annotations
- @SerialVersionUID()
- object SortedSet extends Delegate[SortedSet]
This object provides a set of operations to create
mutable.Sortedset
values.This object provides a set of operations to create
mutable.Sortedset
values.- Annotations
- @SerialVersionUID()
- object Stack extends StrictOptimizedSeqFactory[Stack]
This object provides a set of operations to create
Stack
values.This object provides a set of operations to create
Stack
values.- Annotations
- @SerialVersionUID()
- object StringBuilder extends Serializable
- object TreeMap extends SortedMapFactory[TreeMap]
This object provides a set of operations to create mutable.TreeMap values.
This object provides a set of operations to create mutable.TreeMap values.
- Annotations
- @SerialVersionUID()
- object TreeSet extends SortedIterableFactory[TreeSet]
This object provides a set of operations to create
mutable.TreeSet
values.This object provides a set of operations to create
mutable.TreeSet
values.- Annotations
- @SerialVersionUID()
- object UnrolledBuffer extends StrictOptimizedClassTagSeqFactory[UnrolledBuffer]
- Annotations
- @SerialVersionUID()
- object WeakHashMap extends MapFactory[WeakHashMap]
This object provides a set of operations to create
WeakHashMap
values.This object provides a set of operations to create
WeakHashMap
values.- Annotations
- @SerialVersionUID()
Deprecated Value Members
- val ArrayStack: Stack.type
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Stack instead of ArrayStack; it now uses an array-based implementation
- val Traversable: Iterable.type
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Iterable instead of Traversable
- val WrappedArray: ArraySeq.type
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays
- object ListMap extends MapFactory[ListMap]
This object provides a set of operations to create
mutable.ListMap
values.This object provides a set of operations to create
mutable.ListMap
values.- Annotations
- @SerialVersionUID() @deprecated
- Deprecated
(Since version 2.13.0) Use an immutable.ListMap assigned to a var instead of mutable.ListMap
- object OpenHashMap extends MapFactory[OpenHashMap]
- Annotations
- @deprecated @SerialVersionUID()
- Deprecated
(Since version 2.13.0) Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
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 frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther 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 forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.