scala.collection.mutable
Type members
Classlikes
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.
- Source:
- Buffer.scala
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.
- Source:
- Iterable.scala
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.
- Source:
- Map.scala
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.
- Source:
- Seq.scala
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.
- Source:
- Set.scala
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 229 entries (approximately 500 million). The maximum capacity is 230, but performance will degrade rapidly as 230 is approached.
- Companion:
- object
- Source:
- AnyRefMap.scala
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.
- Type parameters:
- A
the type of this arraybuffer's elements.
- See also:
"Scala's Collection Library overview" section on
Array Buffersfor more information.- Companion:
- object
- Source:
- ArrayBuffer.scala
Factory object for the ArrayBuffer class.
Factory object for the ArrayBuffer class.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- ArrayBuffer.scala
A builder class for arrays.
A builder class for arrays.
- Type parameters:
- T
the type of the elements for the builder.
- Companion:
- object
- Source:
- ArrayBuilder.scala
A companion object for array builders.
A companion object for array builders.
- Companion:
- class
- Source:
- ArrayBuilder.scala
An implementation of a double-ended queue that internally uses a resizable circular buffer.
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.
- Type parameters:
- A
the type of this ArrayDeque's elements.
- Note:
Subclasses must override the
ofArrayprotected method to return a more specific type.- Companion:
- object
- Source:
- ArrayDeque.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- ArrayDeque.scala
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.
- Type parameters:
- T
type of the elements in this wrapped array.
- Companion:
- object
- Source:
- ArraySeq.scala
A companion object used to create instances of ArraySeq.
A companion object used to create instances of ArraySeq.
- Companion:
- class
- Source:
- ArraySeq.scala
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 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 Bitsetsfor more information.- Companion:
- object
- Source:
- BitSet.scala
A Buffer is a growable and shrinkable Seq.
A Buffer is a growable and shrinkable Seq.
- Companion:
- object
- Source:
- Buffer.scala
Base trait for collection builders.
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:
- Builder.scala
This trait forms part of collections that can be cleared with a clear() call.
This trait forms part of collections that can be cleared with a clear() call.
- Source:
- Growable.scala
A trait for cloneable collections.
A trait for cloneable collections.
- Type parameters:
- C
Type of the collection, covariant and with reference types as upperbound.
- Source:
- Cloneable.scala
This class implements mutable maps using a hashtable with red-black trees in the buckets for good worst-case performance on hash collisions.
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 Tablesfor more information.- Companion:
- object
- Source:
- CollisionProofHashMap.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- CollisionProofHashMap.scala
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.
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.
- Companion:
- object
- Source:
- Growable.scala
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.
- Source:
- GrowableBuilder.scala
This class implements mutable maps using a hashtable.
This class implements mutable maps using a hashtable.
- Type parameters:
- 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 Tablesfor more information.- Companion:
- object
- Source:
- HashMap.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- HashMap.scala
This class implements mutable sets using a hashtable.
This class implements mutable sets using a hashtable.
- See also:
"Scala's Collection Library overview" section on
Hash Tablesfor more information.- Companion:
- object
- Source:
- HashSet.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- HashSet.scala
Reusable builder for immutable collections
Reusable builder for immutable collections
- Source:
- ImmutableBuilder.scala
- Companion:
- object
- Source:
- Buffer.scala
- Companion:
- object
- Source:
- IndexedSeq.scala
- Companion:
- object
- Source:
- Iterable.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- Iterable.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- LinkedHashMap.scala
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.
- Type parameters:
- K
the type of the keys contained in this hash map.
- V
the type of the values assigned to keys in this hash map.
- Companion:
- object
- Source:
- LinkedHashMap.scala
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.
- Type parameters:
- A
the type of the elements contained in this set.
- Companion:
- object
- Source:
- LinkedHashSet.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- LinkedHashSet.scala
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.
- Type parameters:
- A
the type of this list buffer's elements.
- See also:
"Scala's Collection Library overview" section on
List Buffersfor more information.- Companion:
- object
- Source:
- ListBuffer.scala
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 229 entries (approximately 500 million). The maximum capacity is 230, but performance will degrade rapidly as 2^30 is approached.
- Companion:
- object
- Source:
- LongMap.scala
- Source:
- Map.scala
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.
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 parameters:
- A
type of the elements in this priority queue.
- Value parameters:
- 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:
- PriorityQueue.scala
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.
- Companion:
- object
- Source:
- Queue.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- Queue.scala
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.
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 parameters:
- Elem
the type of elements that get added to the builder.
- To
the type of collection that it produced.
- Source:
- ReusableBuilder.scala
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.
- Type parameters:
- 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.
- Companion:
- object
- Source:
- SeqMap.scala
- Source:
- Set.scala
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.
- Source:
- Shrinkable.scala
Base type for mutable sorted map collections
Base type for mutable sorted map collections
- Companion:
- object
- Source:
- SortedMap.scala
- Source:
- SortedMap.scala
Base type for mutable sorted set collections
Base type for mutable sorted set collections
- Companion:
- object
- Source:
- SortedSet.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- SortedSet.scala
- Source:
- SortedSet.scala
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.
Note that operations which consume and produce iterables preserve order, rather than reversing it (as would be expected from building a new stack by pushing an element at a time).
- Type parameters:
- A
type of the elements contained in this stack.
- Companion:
- object
- Source:
- Stack.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- Stack.scala
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 the reverse method.)
This Builder can be reused after calling result() without an
intermediate call to clear() in order to build multiple related results.
- Companion:
- object
- Source:
- StringBuilder.scala
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.
- Type parameters:
- K
the type of the keys contained in this tree map.
- V
the type of the values associated with the keys.
- Value parameters:
- ordering
the implicit ordering used to compare objects of type
A.
- Companion:
- object
- Source:
- TreeMap.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- TreeMap.scala
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.
- Type parameters:
- A
the type of the keys contained in this tree set.
- Value parameters:
- ordering
the implicit ordering used to compare objects of type
A.
- Companion:
- object
- Source:
- TreeSet.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- TreeSet.scala
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,
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.
- Companion:
- object
- Source:
- UnrolledBuffer.scala
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.
- Type parameters:
- 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 Mapsfor more information.- Companion:
- object
- Source:
- WeakHashMap.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Source:
- WeakHashMap.scala
Deprecated classlikes
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.
- Type parameters:
- K
the type of the keys contained in this list map.
- V
the type of the values assigned to keys in this list map.
- Companion:
- object
- Deprecated
- Source:
- ListMap.scala
This object provides a set of operations to create Iterable values.
This object provides a set of operations to create Iterable values.
- Companion:
- class
- Deprecated
- Source:
- ListMap.scala
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 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- Deprecated
- Source:
- MultiMap.scala
A mutable hash map based on an open addressing method.
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.
- Type parameters:
- Key
type of the keys in this map.
- Value
type of the values in this map.
- Value parameters:
- initialSize
the initial size of the internal hash table.
- Companion:
- object
- Deprecated
- Source:
- OpenHashMap.scala