scala.collection.mutable
package scala.collection.mutable
Type members
Classlikes
Explicit instantiation of the
Iterable
trait to reduce class file size in subclasses.- Source
- (source)
class AnyRefMap[K <: AnyRef, V] extends AbstractMap[K, V] with MapOps[K, V, [K, V] =>> Map[K, V], AnyRefMap[K, V]] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], AnyRefMap[K, V]] with Serializable
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 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, [A] =>> ArrayBuffer[A], ArrayBuffer[A]] with StrictOptimizedSeqOps[A, [A] =>> ArrayBuffer[A], ArrayBuffer[A]] with IterableFactoryDefaults[A, [A] =>> ArrayBuffer[A]] with DefaultSerializable
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.
- Type Params
- A
-
the type of this arraybuffer's elements.
- See also
- "Scala's Collection Library overview" section on
Array Buffers
for more information. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
final class ArrayBufferView[A](val array: Array[AnyRef], val length: Int) extends AbstractIndexedSeqView[A]
- Source
- (source)
@SerialVersionUID(3L)
class ArrayDeque[A] extends AbstractBuffer[A] with IndexedBuffer[A] with IndexedSeqOps[A, [A] =>> ArrayDeque[A], ArrayDeque[A]] with StrictOptimizedSeqOps[A, [A] =>> ArrayDeque[A], ArrayDeque[A]] with IterableFactoryDefaults[A, [A] =>> ArrayDeque[A]] with ArrayDequeOps[A, [A] =>> ArrayDeque[A], ArrayDeque[A]] with Cloneable[ArrayDeque[A]] with DefaultSerializable
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.
@SerialVersionUID(3L)
trait ArrayDequeOps[A, +CC <: ([_$1] =>> Any), +C <: AnyRef] extends StrictOptimizedSeqOps[A, CC, C]
- Source
- (source)
@SerialVersionUID(3L)
sealed abstract class ArraySeq[T] extends AbstractSeq[T] with IndexedSeq[T] with IndexedSeqOps[T, [T] =>> ArraySeq[T], ArraySeq[T]] with StrictOptimizedSeqOps[T, [T] =>> ArraySeq[T], ArraySeq[T]] with Serializable
@SerialVersionUID(3L)
class BitSet(var elems: Array[Long]) extends AbstractSet[Int] with SortedSet[Int] with SortedSetOps[Int, [A] =>> SortedSet[A], BitSet] with StrictOptimizedIterableOps[Int, [A] =>> Set[A], BitSet] with StrictOptimizedSortedSetOps[Int, [A] =>> SortedSet[A], BitSet] with BitSet with BitSetOps[BitSet] with Serializable
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 lower bound of 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. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
Base trait for collection builders.
After calling
result()
the behavior of a Builder (which is not also a scala.collection.mutable.ReusableBuilder)
is undefined. No further methods should be called. It is common for mutable collections to be their own non-reusable
Builder, in which case result()
simply returns this
.
- See also
- scala.collection.mutable.ReusableBuilder for Builders which can be reused after calling
result()
- Source
- (source)
trait Clearable
This trait forms part of collections that can be cleared
with a clear() call.
- Source
- (source)
A trait for cloneable collections.
- Type Params
- C
-
Type of the collection, covariant and with reference types as upperbound.
- Source
- (source)
final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double)(ordering: Ordering[K]) extends AbstractMap[K, V] with MapOps[K, V, [K, V] =>> Map[K, V], CollisionProofHashMap[K, V]] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], CollisionProofHashMap[K, V]] with StrictOptimizedMapOps[K, V, [K, V] =>> Map[K, V], CollisionProofHashMap[K, V]]
This class implements mutable maps using a hashtable with red-black trees in the buckets for good
worst-case performance on hash collisions. An
Ordering
is required for the element type. Equality
as determined by the Ordering
has to be consistent with equals
and hashCode
. Universal equality
of numeric types is not supported (similar to AnyRefMap
).
- See also
- "Scala's Collection Library overview" section on
Hash Tables
for more information. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
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.
- Source
- (source)
@deprecatedInheritance("HashMap will be made final; use .withDefault for the common use case of computing a default value", "2.13.0")
class HashMap[K, V](initialCapacity: Int, loadFactor: Double) extends AbstractMap[K, V] with MapOps[K, V, [K, V] =>> HashMap[K, V], HashMap[K, V]] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], HashMap[K, V]] with StrictOptimizedMapOps[K, V, [K, V] =>> HashMap[K, V], HashMap[K, V]] with MapFactoryDefaults[K, V, [K, V] =>> HashMap[K, V], [A] =>> Iterable[A]] with Serializable
This class implements mutable maps using a hashtable.
- Type Params
- K
-
the type of the keys contained in this hash map.
- V
-
the type of the values assigned to keys in this hash map.
- See also
- "Scala's Collection Library overview" section on
Hash Tables
for more information. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
final class HashSet[A](initialCapacity: Int, loadFactor: Double) extends AbstractSet[A] with SetOps[A, [A] =>> HashSet[A], HashSet[A]] with StrictOptimizedIterableOps[A, [A] =>> HashSet[A], HashSet[A]] with IterableFactoryDefaults[A, [A] =>> HashSet[A]] with Serializable
This class implements mutable sets using a hashtable.
- See also
- "Scala's Collection Library overview" section on
Hash Tables
for more information. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
trait IndexedBuffer[A] extends IndexedSeq[A] with IndexedSeqOps[A, [A] =>> IndexedBuffer[A], IndexedBuffer[A]] with Buffer[A] with IterableFactoryDefaults[A, [A] =>> IndexedBuffer[A]]
@SerialVersionUID(3L)
trait IndexedSeq[T] extends Seq[T] with IndexedSeq[T] with IndexedSeqOps[T, [T] =>> IndexedSeq[T], IndexedSeq[T]] with IterableFactoryDefaults[T, [T] =>> IndexedSeq[T]]
@SerialVersionUID(3L)
trait IndexedSeqOps[A, +CC <: ([_$1] =>> Any), +C <: AnyRef] extends IndexedSeqOps[A, CC, C] with SeqOps[A, CC, C]
- Source
- (source)
@SerialVersionUID(3L)
@SerialVersionUID(3L)
class LinkedHashMap[K, V] extends AbstractMap[K, V] with SeqMap[K, V] with MapOps[K, V, [K, V] =>> LinkedHashMap[K, V], LinkedHashMap[K, V]] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], LinkedHashMap[K, V]] with StrictOptimizedMapOps[K, V, [K, V] =>> LinkedHashMap[K, V], LinkedHashMap[K, V]] with MapFactoryDefaults[K, V, [K, V] =>> LinkedHashMap[K, V], [A] =>> Iterable[A]] with DefaultSerializable
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.
class LinkedHashSet[A] extends AbstractSet[A] with SetOps[A, [A] =>> LinkedHashSet[A], LinkedHashSet[A]] with StrictOptimizedIterableOps[A, [A] =>> LinkedHashSet[A], LinkedHashSet[A]] with IterableFactoryDefaults[A, [A] =>> LinkedHashSet[A]] with DefaultSerializable
@SerialVersionUID(3L)
@SerialVersionUID(-8428291952499836345L)
class ListBuffer[A] extends AbstractBuffer[A] with SeqOps[A, [A] =>> ListBuffer[A], ListBuffer[A]] with StrictOptimizedSeqOps[A, [A] =>> ListBuffer[A], ListBuffer[A]] with ReusableBuilder[A, List[A]] with IterableFactoryDefaults[A, [A] =>> ListBuffer[A]] with DefaultSerializable
A
Buffer
implementation backed by a list. It provides constant time
prepend and append. Most other operations are linear.
- Type Params
- A
-
the type of this list buffer's elements.
- See also
- "Scala's Collection Library overview" section on
List Buffers
for more information. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
@deprecated("Use an immutable.ListMap assigned to a var instead of mutable.ListMap", "2.13.0")
class ListMap[K, V] extends AbstractMap[K, V] with MapOps[K, V, [K, V] =>> ListMap[K, V], ListMap[K, V]] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], ListMap[K, V]] with StrictOptimizedMapOps[K, V, [K, V] =>> ListMap[K, V], ListMap[K, V]] with MapFactoryDefaults[K, V, [K, V] =>> ListMap[K, V], [A] =>> Iterable[A]] with DefaultSerializable
@SerialVersionUID(3L) @deprecated("Use an immutable.ListMap assigned to a var instead of mutable.ListMap", "2.13.0")
final class LongMap[V] extends AbstractMap[Long, V] with MapOps[Long, V, [K, V] =>> Map[K, V], LongMap[V]] with StrictOptimizedIterableOps[(Long, V), [A] =>> Iterable[A], LongMap[V]] with Serializable
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 229 entries (approximately
500 million). The maximum capacity is 230, but performance will degrade
rapidly as 2^30 is approached.
@SerialVersionUID(3L)
trait MapOps[K, V, +CC <: ([X, Y] =>> MapOps[X, Y, CC, ]), +C <: MapOps[K, V, CC, C]] extends IterableOps[(K, V), [A] =>> Iterable[A], C] with MapOps[K, V, CC, C] with Cloneable[C] with Builder[(K, V), C] with Growable[(K, V)] with Shrinkable[K]
- Source
- (source)
@deprecated("Use a scala.collection.mutable.MultiDict in the scala-collection-contrib module", "2.13.0")
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
K
to Set[V]
objects into multimaps that map K
to V
objects.
- Example
// 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
- Source
- (source)
@deprecated("Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap", "2.13.0") @SerialVersionUID(3L)
@deprecated("Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap", "2.13.0")
class OpenHashMap[Key, Value](initialSize: Int) extends AbstractMap[Key, Value] with MapOps[Key, Value, [Key, Value] =>> OpenHashMap[Key, Value], OpenHashMap[Key, Value]] with StrictOptimizedIterableOps[(Key, Value), [A] =>> Iterable[A], OpenHashMap[Key, Value]] with MapFactoryDefaults[Key, Value, [Key, Value] =>> OpenHashMap[Key, Value], [A] =>> Iterable[A]] with DefaultSerializable
A mutable hash map based on an open addressing method. 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.
sealed class PriorityQueue[A](val ord: Ordering[A]) extends AbstractIterable[A] with Iterable[A] with IterableOps[A, [A] =>> Iterable[A], PriorityQueue[A]] with StrictOptimizedIterableOps[A, [A] =>> Iterable[A], PriorityQueue[A]] with Builder[A, PriorityQueue[A]] with Cloneable[PriorityQueue[A]] with Growable[A] with Serializable
This class implements priority queues using a heap.
To prioritize elements of type A there must be an implicit
Ordering[A] available at creation.
If multiple elements have the same priority in the ordering of this
PriorityQueue, no guarantees are made regarding the order in which elements
are returned by
dequeue
or dequeueAll
. In particular, that means this
class does not guarantee first in first out behaviour that may be
incorrectly inferred from the Queue part of the name of this class.Only the
dequeue
and dequeueAll
methods will return elements in priority
order (while removing elements from the heap). Standard collection methods
including drop
, iterator
, and toString
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 the PriorityQueue
(by using
clone
, for instance) and then dequeue them:
- Type Params
- A
-
type of the elements in this priority queue.
- Value Params
- ord
-
implicit ordering used to compare the elements of type
A
.
- Example
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)
- Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
class Queue[A] extends ArrayDeque[A] with IndexedSeqOps[A, [A] =>> Queue[A], Queue[A]] with StrictOptimizedSeqOps[A, [A] =>> Queue[A], Queue[A]] with IterableFactoryDefaults[A, [A] =>> Queue[A]] with ArrayDequeOps[A, [A] =>> Queue[A], Queue[A]] with Cloneable[Queue[A]] with DefaultSerializable
@SerialVersionUID(3L)
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.In general no method other than
clear()
may be called after result()
.
It is up to subclasses to implement and to document other allowed sequences
of operations (e.g. calling other methods after result()
in order to obtain
different snapshots of a collection under construction).
- Type Params
- Elem
-
the type of elements that get added to the builder.
- To
-
the type of collection that it produced.
- Source
- (source)
@SerialVersionUID(3L)
trait SeqMap[K, V] extends Map[K, V] with SeqMap[K, V] with MapOps[K, V, [K, V] =>> SeqMap[K, V], SeqMap[K, V]] with MapFactoryDefaults[K, V, [K, V] =>> SeqMap[K, V], [A] =>> Iterable[A]]
A generic trait for ordered mutable maps. Concrete classes have to provide
functionality for the abstract methods in
SeqMap
.@SerialVersionUID(3L)
trait SetOps[A, +CC <: ([X] =>> Any), +C <: SetOps[A, CC, C]] extends SetOps[A, CC, C] with IterableOps[A, CC, C] with Cloneable[C] with Builder[A, C] with Growable[A] with Shrinkable[A]
- Source
- (source)
@SerialVersionUID(3L)
trait SortedMapOps[K, V, +CC <: ([X, Y] =>> Map[X, Y] & SortedMapOps[X, Y, CC, ]), +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C] with MapOps[K, V, [K, V] =>> Map[K, V], C]
- Source
- (source)
@SerialVersionUID(3L)
trait SortedSetOps[A, +CC <: ([X] =>> SortedSet[X]), +C <: SortedSetOps[A, CC, C]] extends SetOps[A, [A] =>> Set[A], C] with SortedSetOps[A, CC, C]
- Source
- (source)
@migration("Stack is now based on an ArrayDeque instead of a linked list", "2.13.0")
class Stack[A] extends ArrayDeque[A] with IndexedSeqOps[A, [A] =>> Stack[A], Stack[A]] with StrictOptimizedSeqOps[A, [A] =>> Stack[A], Stack[A]] with IterableFactoryDefaults[A, [A] =>> Stack[A]] with ArrayDequeOps[A, [A] =>> Stack[A], Stack[A]] with Cloneable[Stack[A]] with DefaultSerializable
@SerialVersionUID(3L)
@SerialVersionUID(3L)
final class StringBuilder(val underlying: StringBuilder) extends AbstractSeq[Char] with ReusableBuilder[Char, String] with IndexedSeq[Char] with IndexedSeqOps[Char, [T] =>> IndexedSeq[T], StringBuilder] with IterableFactoryDefaults[Char, [T] =>> IndexedSeq[T]] with CharSequence with Serializable
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 the reverse
method.)sealed class TreeMap[K, V] extends AbstractMap[K, V] with SortedMap[K, V] with SortedMapOps[K, V, [K, V] =>> TreeMap[K, V], TreeMap[K, V]] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], TreeMap[K, V]] with StrictOptimizedMapOps[K, V, [K, V] =>> Map[K, V], TreeMap[K, V]] with StrictOptimizedSortedMapOps[K, V, [K, V] =>> TreeMap[K, V], TreeMap[K, V]] with SortedMapFactoryDefaults[K, V, [K, V] =>> TreeMap[K, V], [A] =>> Iterable[A], [K, V] =>> Map[K, V]] with DefaultSerializable
A mutable sorted map implemented using a mutable red-black tree as underlying data structure.
@SerialVersionUID(3L)
sealed class TreeSet[A] extends AbstractSet[A] with SortedSet[A] with SortedSetOps[A, [A] =>> TreeSet[A], TreeSet[A]] with StrictOptimizedIterableOps[A, [A] =>> Set[A], TreeSet[A]] with StrictOptimizedSortedSetOps[A, [A] =>> TreeSet[A], TreeSet[A]] with SortedSetFactoryDefaults[A, [A] =>> TreeSet[A], [A] =>> Set[A]] with DefaultSerializable
@SerialVersionUID(3L)
@SerialVersionUID(3L)
sealed class UnrolledBuffer[T](val tag: ClassTag[T]) extends AbstractBuffer[T] with Buffer[T] with Seq[T] with SeqOps[T, [T] =>> UnrolledBuffer[T], UnrolledBuffer[T]] with StrictOptimizedSeqOps[T, [T] =>> UnrolledBuffer[T], UnrolledBuffer[T]] with EvidenceIterableFactoryDefaults[T, [T] =>> UnrolledBuffer[T], [T] =>> ClassTag[T]] with Builder[T, UnrolledBuffer[T]] with DefaultSerializable
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,
where n
is the number of elements, and m
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.
@SerialVersionUID(3L)
@SerialVersionUID(3L)
class WeakHashMap[K, V] extends JMapWrapper[K, V] with JMapWrapperLike[K, V, [K, V] =>> WeakHashMap[K, V], WeakHashMap[K, V]] with MapFactoryDefaults[K, V, [K, V] =>> WeakHashMap[K, V], [A] =>> Iterable[A]]
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
.
- Type Params
- K
-
type of keys contained in this map
- V
-
type of values associated with the keys
- See also
- "Scala's Collection Library overview" section on
Weak Hash Maps
for more information. - Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
Types
@deprecated("Use Stack instead of ArrayStack; it now uses an array-based implementation", "2.13.0")
- Source
- (source)
@deprecated("mutable.LinearSeq has been removed; use LinearSeq with mutable.Seq instead", "2.13.0")
- Source
- (source)
@deprecated("Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays", "2.13.0")
- Source
- (source)
Value members
Fields
@deprecated("Use Stack instead of ArrayStack; it now uses an array-based implementation", "2.13.0")
- Source
- (source)
@deprecated("Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays", "2.13.0")
- Source
- (source)