scala.collection
package scala.collection
Type members
Classlikes
@SerialVersionUID(3L)
Explicit instantiation of the
IndexedSeqView
trait to reduce class file size in subclasses.- Source
- (source)
Explicit instantiation of the
Iterable
trait to reduce class file size in subclasses.- Source
- (source)
Explicit instantiation of the
Iterator
trait to reduce class file size in subclasses.- Source
- (source)
@SerialVersionUID(3L)
Explicit instantiation of the
MapView
trait to reduce class file size in subclasses.- Source
- (source)
@SerialVersionUID(3L)
Explicit instantiation of the
SeqView
trait to reduce class file size in subclasses.- Source
- (source)
@SerialVersionUID(3L)
Explicit instantiation of the
View
trait to reduce class file size in subclasses.- Source
- (source)
This class serves as a wrapper for
Array
s with many of the operations found in
indexed sequences. Where needed, instances of arrays are implicitly converted
into this class. There is generally no reason to create an instance explicitly or use
an ArrayOps
type. It is better to work with plain Array
types instead and rely on
the implicit conversion to ArrayOps
when calling a method (which does not actually
allocate an instance of ArrayOps
because it is a value class).Neither
Array
nor ArrayOps
are proper collection types
(i.e. they do not extend Iterable
or even IterableOnce
). mutable.ArraySeq
and
immutable.ArraySeq
serve this purpose.The difference between this class and
ArraySeq
s is that calling transformer methods such as
filter
and map
will yield an array, whereas an ArraySeq
will remain an ArraySeq
.
@SerialVersionUID(3L)
Buffered iterators are iterators which provide a method
head
that inspects the next element without discarding it.
- Source
- (source)
@implicitNotFound(msg = "Cannot construct a collection of type ${C} with elements of type ${A} based on a collection of type ${From}.")
Builds a collection of type
C
from elements of type A
when a source collection of type From
is available.
Implicit instances of BuildFrom
are available for all collection types.
trait ClassTagIterableFactory[+CC <: ([_$44] =>> Any)] extends EvidenceIterableFactory[CC, [T] =>> ClassTag[T]]
trait ClassTagSeqFactory[+CC <: ([A] =>> SeqOps[A, [A] =>> Seq[A], Seq[A]])] extends ClassTagIterableFactory[CC]
@deprecated("DefaultMap is no longer necessary; extend Map directly", "2.13.0")
A default map which builds a default
immutable.Map
implementation for all
transformations.
- Source
- (source)
trait EvidenceIterableFactoryDefaults[+A, +CC <: ([x] =>> IterableOps[x, CC, CC[x]]), Ev <: ([_$12] =>> Any)] extends IterableOps[A, CC, CC[A]]
This trait provides default implementations for the factory methods
fromSpecific
and
newSpecificBuilder
that need to be refined when implementing a collection type that refines
the CC
and C
type parameters. It is used for collections that have an additional constraint,
expressed by the evidenceIterableFactory
method.The default implementations in this trait can be used in the common case when
CC[A]
is the
same as C
.
- Source
- (source)
A factory that builds a collection of type
C
with elements of type A
.This is a general form of any factory (IterableFactory,
SortedIterableFactory, MapFactory and SortedMapFactory) whose
element type is fixed.
trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, [A] =>> IndexedSeq[A], IndexedSeq[A]] with IterableFactoryDefaults[A, [A] =>> IndexedSeq[A]]
@SerialVersionUID(3L)
trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, [A] =>> Iterable[A], Iterable[A]] with IterableFactoryDefaults[A, [A] =>> Iterable[A]]
@SerialVersionUID(3L)
trait IterableFactoryDefaults[+A, +CC <: ([x] =>> IterableOps[x, CC, CC[x]])] extends IterableOps[A, CC, CC[A]]
This trait provides default implementations for the factory methods
fromSpecific
and
newSpecificBuilder
that need to be refined when implementing a collection type that refines
the CC
and C
type parameters.The default implementations in this trait can be used in the common case when
CC[A]
is the
same as C
.
- Source
- (source)
A template trait for collections which can be traversed either once only
or one or more times.
Note:
IterableOnce
does not extend IterableOnceOps. This is different than the general
design of the collections library, which uses the following pattern:trait Seq extends Iterable with SeqOps
trait SeqOps extends IterableOps
trait IndexedSeq extends Seq with IndexedSeqOps
trait IndexedSeqOps extends SeqOps
The goal is to provide a minimal interface without any sequential operations. This allows
third-party extension like Scala parallel collections to integrate at the level of IterableOnce
without inheriting unwanted implementations.
This implementation trait can be mixed into an
IterableOnce
to get the basic methods that are shared between
Iterator
and Iterable
. The IterableOnce
must support multiple calls to iterator
but may or may not
return the same Iterator
every time.- Source
- (source)
trait IterableOps[+A, +CC <: ([_$1] =>> Any), +C] extends IterableOnce[A] with IterableOnceOps[A, CC, C]
Base trait for Iterable operations
VarianceNote
We require that for all child classes of Iterable the variance of
the child class and the variance of the
C
parameter passed to IterableOps
are the same. We cannot express this since we lack variance polymorphism. That's
why we have to resort at some places to write C[A @uncheckedVariance]
.
- Type Params
- C
-
type of the collection (e.g.
List[Int]
,String
,BitSet
). Operations returning a collection with the same type of element (e.g.drop
,filter
) return aC
. - CC
-
type constructor of the collection (e.g.
List
,Set
). Operations returning a collection with a different type of elementB
(e.g.map
) return aCC[B]
.
- Companion
- object
- Source
- (source)
trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, [A] =>> Iterator[A], Iterator[A]]
Iterators are data structures that allow to iterate over a sequence
of elements. They have a
hasNext
method for checking
if there is a next element available, and a next
method
which returns the next element and advances the iterator.An iterator is mutable: most operations on it change its state. While it is often used
to iterate through the elements of a collection, it can also be used without
being backed by any collection (see constructors on the companion object).
It is of particular importance to note that, unless stated otherwise, one should never
use an iterator after calling a method on it. The two most important exceptions
are also the sole abstract methods:
next
and hasNext
.Both these methods can be called any number of times without having to discard the
iterator. Note that even
hasNext
may cause mutation -- such as when iterating
from an input stream, where it will block until the stream is closed or some
input becomes available.Consider this example for safe and unsafe use:
def f[A](it: Iterator[A]) = {
if (it.hasNext) { // Safe to reuse "it" after "hasNext"
it.next() // Safe to reuse "it" after "next"
val remainder = it.drop(2) // it is *not* safe to use "it" again after this line!
remainder.take(2) // it is *not* safe to use "remainder" after this line!
} else it
}
@SerialVersionUID(3L)
@deprecated("Use `scala.jdk.CollectionConverters` instead", "2.13.0")
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)
- Source
- (source)
@SerialVersionUID(3L)
trait LinearSeqOps[+A, +CC <: ([X] =>> LinearSeq[X]), +C <: LinearSeq[A] & LinearSeqOps[A, CC, C]] extends SeqOps[A, CC, C]
Base trait for linear Seq operations
- Source
- (source)
@SerialVersionUID(3L)
trait MapFactoryDefaults[K, +V, +CC <: ([x, y] =>> IterableOps[(x, y), [A] =>> Iterable[A], Iterable[(x, y)]]), +WithFilterCC <: ([x] =>> IterableOps[x, WithFilterCC, WithFilterCC[x]] & Iterable[x])] extends MapOps[K, V, CC, CC[K, V]] with IterableOps[(K, V), WithFilterCC, CC[K, V]]
This trait provides default implementations for the factory methods
fromSpecific
and
newSpecificBuilder
that need to be refined when implementing a collection type that refines
the CC
and C
type parameters. It is used for maps.Note that in maps, the
CC
type of the map is not the same as the CC
type for the
underlying iterable (which is fixed to Map
in MapOps). This trait has therefore
two type parameters CC
and WithFilterCC
. The withFilter
method inherited from
IterableOps
is overridden with a compatible default implementation.The default implementations in this trait can be used in the common case when
CC[A]
is the
same as C
.
- Source
- (source)
trait MapOps[K, +V, +CC <: ([_$1, _$2] =>> IterableOps[, AnyConstr, ]), +C] extends IterableOps[(K, V), [A] =>> Iterable[A], C] with PartialFunction[K, V]
Base Map implementation type
- Type Params
- C
-
type of the map (e.g.
HashMap[Int, String]
). Operations returning a collection with the same type of element (e.g.drop
,filter
) return aC
. - CC
-
type constructor of the map (e.g.
HashMap
). Operations returning a collection with a different type of entries(L, W)
(e.g.map
) return aCC[L, W]
. - K
-
Type of keys
- V
-
Type of values
- Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
trait SeqMap[K, +V] extends Map[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 maps. Concrete classes have to provide
functionality for the abstract methods in
SeqMap
.Base trait for Seq operations
- Type Params
- A
-
the element type of the collection
- C
-
type of the collection (e.g.
List[Int]
,String
,BitSet
). Operations returning a collection with the same type of element (e.g.drop
,filter
) return aC
. - CC
-
type constructor of the collection (e.g.
List
,Set
). Operations returning a collection with a different type of elementB
(e.g.map
) return aCC[B]
.
- Companion
- object
- Source
- (source)
@SerialVersionUID(3L)
trait SetOps[A, +CC <: ([_$1] =>> Any), +C <: SetOps[A, CC, C]] extends IterableOps[A, CC, C] with A => Boolean
Base trait for set operations
- Source
- (source)
trait SortedMap[K, +V] extends Map[K, V] with SortedMapOps[K, V, [K, V] =>> SortedMap[K, V], SortedMap[K, V]] with SortedMapFactoryDefaults[K, V, [K, V] =>> SortedMap[K, V], [A] =>> Iterable[A], [K, V] =>> Map[K, V]]
A Map whose keys are sorted according to a scala.math.Ordering
@SerialVersionUID(3L)
trait SortedMapFactoryDefaults[K, +V, +CC <: ([x, y] =>> Map[x, y] & SortedMapOps[x, y, CC, CC[x, y]] & UnsortedCC[x, y]), +WithFilterCC <: ([x] =>> IterableOps[x, WithFilterCC, WithFilterCC[x]] & Iterable[x]), +UnsortedCC <: ([x, y] =>> Map[x, y])] extends SortedMapOps[K, V, CC, CC[K, V]] with MapOps[K, V, UnsortedCC, CC[K, V]]
This trait provides default implementations for the factory methods
fromSpecific
and
newSpecificBuilder
that need to be refined when implementing a collection type that refines
the CC
and C
type parameters. It is used for sorted maps.Note that in sorted maps, the
CC
type of the map is not the same as the CC
type for the
underlying map (which is fixed to Map
in SortedMapOps). This trait has therefore
three type parameters CC
, WithFilterCC
and UnsortedCC
. The withFilter
method inherited
from IterableOps
is overridden with a compatible default implementation.The default implementations in this trait can be used in the common case when
CC[A]
is the
same as C
.
- Source
- (source)
@SerialVersionUID(3L)
trait SortedSetFactoryDefaults[+A, +CC <: ([X] =>> SortedSet[X] & SortedSetOps[X, CC, CC[X]]), +WithFilterCC <: ([x] =>> IterableOps[x, WithFilterCC, WithFilterCC[x]] & Set[x])] extends SortedSetOps[A, CC, CC[A]]
This trait provides default implementations for the factory methods
fromSpecific
and
newSpecificBuilder
that need to be refined when implementing a collection type that refines
the CC
and C
type parameters. It is used for sorted sets.Note that in sorted sets, the
CC
type of the set is not the same as the CC
type for the
underlying iterable (which is fixed to Set
in SortedSetOps). This trait has therefore
two type parameters CC
and WithFilterCC
. The withFilter
method inherited from
IterableOps
is overridden with a compatible default implementation.The default implementations in this trait can be used in the common case when
CC[A]
is the
same as C
.
- Source
- (source)
- Type Params
- A
-
Type of elements (e.g.
Int
,Boolean
, etc.) - C
-
Type of collection (e.g.
List[Int]
,TreeMap[Int, String]
, etc.)
- Source
- (source)
Steppers exist to enable creating Java streams over Scala collections, see
scala.jdk.StreamConverters. Besides that use case, they allow iterating over collections
holding unboxed primitives (e.g.,
Array[Int]
) without boxing the elements.Steppers have an iterator-like interface with methods
hasStep
and nextStep()
. The difference
to iterators - and the reason Stepper
is not a subtype of Iterator
- is that there are
hand-specialized variants of Stepper
for Int
, Long
and Double
(IntStepper, etc.).
These enable iterating over collections holding unboxed primitives (e.g., Arrays,
scala.jdk.Accumulators) without boxing the elements.The selection of primitive types (
Int
, Long
and Double
) matches the hand-specialized
variants of Java Streams (java.util.stream.Stream, java.util.stream.IntStream, etc.)
and the corresponding Java Spliterators (java.util.Spliterator, java.util.Spliterator.OfInt, etc.).Steppers can be converted to Scala Iterators, Java Iterators and Java Spliterators. Primitive
Steppers are converted to the corresponding primitive Java Iterators and Spliterators.
An implicit StepperShape instance is used in the IterableOnce.stepper to return a possibly
specialized Stepper
S
according to the element type T
.
trait StrictOptimizedClassTagSeqFactory[+CC <: ([A] =>> SeqOps[A, [A] =>> Seq[A], Seq[A]])] extends ClassTagSeqFactory[CC]
- Source
- (source)
Trait that overrides iterable operations to take advantage of strict builders.
- Type Params
- A
-
Elements type
- C
-
Collection type
- CC
-
Collection type constructor
- Source
- (source)
trait StrictOptimizedLinearSeqOps[+A, +CC <: ([X] =>> LinearSeq[X]), +C <: LinearSeq[A] & StrictOptimizedLinearSeqOps[A, CC, C]] extends LinearSeqOps[A, CC, C] with StrictOptimizedSeqOps[A, CC, C]
- Source
- (source)
trait StrictOptimizedMapOps[K, +V, +CC <: ([_$1, _$2] =>> IterableOps[, AnyConstr, ]), +C] extends MapOps[K, V, CC, C] with StrictOptimizedIterableOps[(K, V), [A] =>> Iterable[A], C]
Trait that overrides map operations to take advantage of strict builders.
- Type Params
- C
-
Collection type
- CC
-
Collection type constructor
- K
-
Type of keys
- V
-
Type of values
- Source
- (source)
trait StrictOptimizedSeqFactory[+CC <: ([A] =>> SeqOps[A, [A] =>> Seq[A], Seq[A]])] extends SeqFactory[CC]
- Source
- (source)
trait StrictOptimizedSeqOps[+A, +CC <: ([_$1] =>> Any), +C] extends SeqOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C]
Trait that overrides operations on sequences in order
to take advantage of strict builders.
- Source
- (source)
trait StrictOptimizedSetOps[A, +CC <: ([_$1] =>> Any), +C <: SetOps[A, CC, C]] extends SetOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C]
Trait that overrides set operations to take advantage of strict builders.
- Type Params
- A
-
Elements type
- C
-
Collection type
- CC
-
Collection type constructor
- Source
- (source)
trait StrictOptimizedSortedMapOps[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 StrictOptimizedMapOps[K, V, [K, V] =>> Map[K, V], C]
Trait that overrides sorted map operations to take advantage of strict builders.
- Type Params
- C
-
Collection type
- CC
-
Collection type constructor
- K
-
Type of keys
- V
-
Type of values
- Source
- (source)
trait StrictOptimizedSortedSetOps[A, +CC <: ([X] =>> SortedSet[X]), +C <: SortedSetOps[A, CC, C]] extends SortedSetOps[A, CC, C] with StrictOptimizedSetOps[A, [A] =>> Set[A], C]
Trait that overrides sorted set operations to take advantage of strict builders.
- Type Params
- A
-
Elements type
- C
-
Collection type
- CC
-
Collection type constructor
- Source
- (source)
trait View[+A] extends Iterable[A] with IterableOps[A, [A] =>> View[A], View[A]] with IterableFactoryDefaults[A, [A] =>> View[A]] with Serializable
@SerialVersionUID(3L)
@SerialVersionUID(3L)
A template trait that contains just the
map
, flatMap
, foreach
and withFilter
methods
of trait Iterable
.
- Type Params
- A
-
Element type (e.g.
Int
) - CC
-
Collection type constructor (e.g.
List
)
- Source
- (source)
Types
@deprecated("Use SeqOps (for the methods) or IndexedSeqOps (for fast indexed access) instead of ArrayLike", "2.13.0")
- Source
- (source)