Scala Standard Library 2.13.16 - scala.collection
Keywords: Scala Standard Library 2.13.16 scala.collection

Scala Standard Library2.13.16 < Back


# Packages

-  package root

  This is the documentation for the Scala standard library.

  This is the documentation for the Scala standard library.

  #### Package structure

  The scala package contains core types like `Int`, `Float`, `Array` or `Option` 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 framework
    - `scala.collection.immutable` - Immutable, sequential data-structures such as `Vector`, `List`, `Range`, `HashMap` or `HashSet`
    - `scala.collection.mutable` - Mutable, sequential data-structures such as `ArrayBuffer`, `StringBuilder`, `HashMap` or `HashSet`
    - `scala.collection.concurrent` - Mutable, concurrent data-structures such as `TrieMap`
  - `scala.concurrent` - Primitives for concurrent programming such as `Futures` and `Promises`
  - `scala.io` - Input and output operations
  - `scala.math` - Basic math functions and additional numeric types like `BigInt` and `BigDecimal`
  - `scala.sys` - Interaction with other processes and the operating system
  - `scala.util.matching` - Regular expressions

  Other 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 for `scala.collection.immutable.List`.

  Other aliases refer to classes provided by the underlying platform. For example, on the JVM, `String` is an alias for `java.lang.String`.

  Definition Classes
    root
-  package scala

  Core Scala types.

  Core Scala types. They are always available without an explicit import.

  Definition Classes
    root
-  package annotation
  Definition Classes
    scala
-  package beans
  Definition Classes
    scala
-  package collection
  Definition Classes
    scala
-  package concurrent
-  package convert
-  package generic
-  package immutable
-  package mutable
- +:
- :+
- AbstractIndexedSeqView
- AbstractIterable
- AbstractIterator
- AbstractMap
- AbstractMapView
- AbstractSeq
- AbstractSeqView
- AbstractSet
- AbstractView
- AnyStepper
- ArrayOps
- BitSet
- BitSetOps
- BufferedIterator
- BuildFrom
- BuildFromLowPriority1
- BuildFromLowPriority2
- ClassTagIterableFactory
- ClassTagSeqFactory
- DefaultMap
- DoubleStepper
- EvidenceIterableFactory
- EvidenceIterableFactoryDefaults
- Factory
- Hashing
- IndexedSeq
- IndexedSeqOps
- IndexedSeqView
- IntStepper
- Iterable
- IterableFactory
- IterableFactoryDefaults
- IterableOnce
- IterableOnceExtensionMethods
- IterableOnceOps
- IterableOps
- Iterator
- JavaConverters
- LazyZip2
- LazyZip3
- LazyZip4
- LinearSeq
- LinearSeqOps
- LongStepper
- Map
- MapFactory
- MapFactoryDefaults
- MapOps
- MapView
- MapViewFactory
- Searching
- Seq
- SeqFactory
- SeqMap
- SeqOps
- SeqView
- Set
- SetOps
- SortedIterableFactory
- SortedMap
- SortedMapFactory
- SortedMapFactoryDefaults
- SortedMapOps
- SortedOps
- SortedSet
- SortedSetFactoryDefaults
- SortedSetOps
- SpecificIterableFactory
- Stepper
- StepperShape
- StepperShapeLowPriority1
- StepperShapeLowPriority2
- StrictOptimizedClassTagSeqFactory
- StrictOptimizedIterableOps
- StrictOptimizedLinearSeqOps
- StrictOptimizedMapOps
- StrictOptimizedSeqFactory
- StrictOptimizedSeqOps
- StrictOptimizedSetOps
- StrictOptimizedSortedMapOps
- StrictOptimizedSortedSetOps
- StringOps
- StringView
- View
- WithFilter
-  package compat
  Definition Classes
    scala
-  package concurrent

  This package object contains primitives for concurrent and parallel programming.

  This package object contains primitives for concurrent and parallel programming.

  #### Guide

  A more detailed guide to Futures and Promises, including discussion and examples can be found at https://docs.scala-lang.org/overviews/core/futures.html.

  #### Common Imports

  When working with Futures, you will often find that importing the whole concurrent package is convenient:

      import scala.concurrent._

  When using things like `Future`s, it is often required to have an implicit `ExecutionContext` in scope. The general advice for these implicits are as follows.

  If the code in question is a class or method definition, and no `ExecutionContext` is available, request one from the caller by adding an implicit parameter list:

      def myMethod(myParam: MyType)(implicit ec: ExecutionContext) = …
      //Or
      class MyClass(myParam: MyType)(implicit ec: ExecutionContext) { … }

  This allows the caller of the method, or creator of the instance of the class, to decide which `ExecutionContext` should be used.

  For typical REPL usage and experimentation, importing the global `ExecutionContext` is often desired.

      import scala.concurrent.ExcutionContext.Implicits.global

  #### Specifying Durations

  Operations often require a duration to be specified. A duration DSL is available to make defining these easier:

      import scala.concurrent.duration._
      val d: Duration = 10.seconds

  #### Using Futures For Non-blocking Computation

  Basic use of futures is easy with the factory method on Future, which executes a provided function asynchronously, handing you back a future result of that function without blocking the current thread. In order to create the Future you will need either an implicit or explicit ExecutionContext to be provided:

      import scala.concurrent._
      import ExecutionContext.Implicits.global  // implicit execution context

      val firstZebra: Future[Int] = Future {
        val words = Files.readAllLines("/etc/dictionaries-common/words").asScala
        words.indexOfSlice("zebra")
      }

  #### Avoid Blocking

  Although blocking is possible in order to await results (with a mandatory timeout duration):

      import scala.concurrent.duration._
      Await.result(firstZebra, 10.seconds)

  and although this is sometimes necessary to do, in particular for testing purposes, blocking in general is discouraged when working with Futures and concurrency in order to avoid potential deadlocks and improve performance. Instead, use callbacks or combinators to remain in the future domain:

      val animalRange: Future[Int] = for {
        aardvark <- firstAardvark
        zebra <- firstZebra
      } yield zebra - aardvark

      animalRange.onSuccess {
        case x if x > 500000 => println("It's a long way from Aardvark to Zebra")
      }

  Definition Classes
    scala
-  package io
  Definition Classes
    scala
-  package jdk

  The jdk package contains utilities to interact with JDK classes.

  The jdk package contains utilities to interact with JDK classes.

  This packages offers a number of converters, that are able to wrap or copy types from the scala library to equivalent types in the JDK class library and vice versa:

  - CollectionConverters, converting collections like scala.collection.Seq, scala.collection.Map, scala.collection.Set, scala.collection.mutable.Buffer, scala.collection.Iterator and scala.collection.Iterable to their JDK counterparts
  - OptionConverters, converting between Option and java.util.Optional and primitive variations
  - StreamConverters, to create JDK Streams from scala collections
  - DurationConverters, for conversions between scala scala.concurrent.duration.FiniteDuration and java.time.Duration
  - FunctionConverters, from scala Functions to java java.util.function.Function, java.util.function.UnaryOperator, java.util.function.Consumer and java.util.function.Predicate, as well as primitive variations and Bi-variations.

  By convention, converters that wrap an object to provide a different interface to the same underlying data structure use .asScala and .asJava extension methods, whereas converters that copy the underlying data structure use .toScala and .toJava.

  In the javaapi package, the same converters can be found with a java-friendly interface that don't rely on implicit enrichments.

  Additionally, this package offers Accumulators, capable of efficiently traversing JDK Streams.

  Definition Classes
    scala
-  package math

  The package object `scala.math` contains methods for performing basic numeric operations such as elementary exponential, logarithmic, root and trigonometric functions.

  The package object `scala.math` contains methods for performing basic numeric operations such as elementary exponential, logarithmic, root and trigonometric functions.

  All methods forward to java.lang.Math unless otherwise noted.

  Definition Classes
    scala
  See also

    java.lang.Math

-  package ref
  Definition Classes
    scala
-  package reflect
  Definition Classes
    scala
-  package sys

  The package object `scala.sys` contains methods for reading and altering core aspects of the virtual machine as well as the world outside of it.

  The package object `scala.sys` contains methods for reading and altering core aspects of the virtual machine as well as the world outside of it.

  Definition Classes
    scala
-  package util
  Definition Classes
    scala

p

scala

# collection

#### package collection

Source
  package.scala

Linear Supertypes
AnyRef, Any
Content Hierarchy

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. collection
2. AnyRef
3. Any

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Package Members

1.  package concurrent
2.  package convert
3.  package generic
4.  package immutable
5.  package mutable

### Type Members

1.  abstract class AbstractIndexedSeqView[+A] extends AbstractSeqView[A] with IndexedSeqView[A]

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

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

   Annotations
     @SerialVersionUID()
2.  abstract class AbstractIterable[+A] extends Iterable[A]

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

3.  abstract class AbstractIterator[+A] extends Iterator[A]

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

4.  abstract class AbstractMap[K, +V] extends AbstractIterable[(K, V)] with Map[K, V]

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

5.  abstract class AbstractMapView[K, +V] extends AbstractView[(K, V)] with MapView[K, V]

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

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

   Annotations
     @SerialVersionUID()
6.  abstract class AbstractSeq[+A] extends AbstractIterable[A] with Seq[A]

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

7.  abstract class AbstractSeqView[+A] extends AbstractView[A] with SeqView[A]

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

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

   Annotations
     @SerialVersionUID()
8.  abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A]

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

9.  abstract class AbstractView[+A] extends AbstractIterable[A] with View[A]

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

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

   Annotations
     @SerialVersionUID()
10.  trait AnyStepper[+A] extends Stepper[A]

    A Stepper for arbitrary element types.

    A Stepper for arbitrary element types. See Stepper.

11.  final class ArrayOps[A] extends AnyVal

    This class serves as a wrapper for `Array`s with many of the operations found in indexed sequences.

    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`.

    A

      type of the elements contained in this array.

12.  trait BitSet extends SortedSet[Int] with BitSetOps[BitSet]

    Base type of bitsets.

    Base type of bitsets.

    This trait provides most of the operations of a `BitSet` independently of its representation. It is inherited by all concrete implementations of bitsets.

13.  trait BitSetOps[+C <: BitSet with BitSetOps[C]] extends SortedSetOps[Int, SortedSet, C]

    Base implementation type of bitsets

14.  trait BufferedIterator[+A] extends Iterator[A]

    Buffered iterators are iterators which provide a method `head` that inspects the next element without discarding it.

15.  trait BuildFrom[-From, -A, +C] extends Any

    Builds a collection of type `C` from elements of type `A` when a source collection of type `From` is available.

    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.

    From

      Type of source collection

    A

      Type of elements (e.g. `Int`, `Boolean`, etc.)

    C

      Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.)

    Annotations
      @implicitNotFound()
16.  trait BuildFromLowPriority1 extends BuildFromLowPriority2
17.  trait BuildFromLowPriority2 extends AnyRef
18.  trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassTag]

    Base trait for companion objects of collections that require an implicit `ClassTag`.

    Base trait for companion objects of collections that require an implicit `ClassTag`.

    CC

      Collection type constructor (e.g. `ArraySeq`)

19.  trait ClassTagSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends ClassTagIterableFactory[CC]

    CC

      Collection type constructor (e.g. `ArraySeq`)

20.  trait DoubleStepper extends Stepper[Double]

    A Stepper for Doubles.

    A Stepper for Doubles. See Stepper.

21.  trait EvidenceIterableFactory[+CC[_], Ev[_]] extends Serializable

    Base trait for companion objects of collections that require an implicit evidence.

    Base trait for companion objects of collections that require an implicit evidence.

    CC

      Collection type constructor (e.g. `ArraySeq`)

    Ev

      Unary type constructor for the implicit evidence required for an element type (typically `Ordering` or `ClassTag`)

22.  trait EvidenceIterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]], Ev[_]] 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.

    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`.

23.  trait Factory[-A, +C] extends Any

    A factory that builds a collection of type `C` with elements of type `A`.

    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.

    A

      Type of elements (e.g. `Int`, `Boolean`, etc.)

    C

      Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.)

24.  trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] with IterableFactoryDefaults[A, IndexedSeq]

    Base trait for indexed sequences that have efficient `apply` and `length`

25.  trait IndexedSeqOps[+A, +CC[_], +C] extends SeqOps[A, CC, C]

    Base trait for indexed Seq operations

26.  trait IndexedSeqView[+A] extends IndexedSeqOps[A, View, View[A]] with SeqView[A]

    View defined in terms of indexing a range

27.  trait IntStepper extends Stepper[Int]

    A Stepper for Ints.

    A Stepper for Ints. See Stepper.

28.  trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterable[A]] with IterableFactoryDefaults[A, Iterable]

    Base trait for generic collections.

    Base trait for generic collections.

    A

      the element type of the collection

29.  trait IterableFactory[+CC[_]] extends Serializable

    Base trait for companion objects of unconstrained collection types that may require multiple traversals of a source collection to build a target collection `CC`.

    Base trait for companion objects of unconstrained collection types that may require multiple traversals of a source collection to build a target collection `CC`.

    CC

      Collection type constructor (e.g. `List`)

30.  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.

    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`.

31.  trait IterableOnce[+A] extends Any

    A template trait for collections which can be traversed either once only or one or more times.

    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.

32.  final class IterableOnceExtensionMethods[A] extends AnyVal
33.  trait IterableOnceOps[+A, +CC[_], +C] extends Any

    This implementation trait can be mixed into an `IterableOnce` to get the basic methods that are shared between `Iterator` and `Iterable`.

    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.

34.  trait IterableOps[+A, +CC[_], +C] extends IterableOnce[A] with IterableOnceOps[A, CC, C]

    Base trait for Iterable operations

    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]`.

    CC

      type constructor of the collection (e.g. `List`, `Set`). Operations returning a collection with a different type of element `B` (e.g. `map`) return a `CC[B]`.

    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 a `C`.

35.  trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Iterator[A]]

    Iterators are data structures that allow to iterate over a sequence of elements.

    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
        }

36.  final class LazyZip2[+El1, +El2, C1] extends AnyRef

    Decorator representing lazily zipped pairs.

37.  final class LazyZip3[+El1, +El2, +El3, C1] extends AnyRef

    Decorator representing lazily zipped triples.

38.  final class LazyZip4[+El1, +El2, +El3, +El4, C1] extends AnyRef

    Decorator representing lazily zipped 4-tuples.

39.  trait LinearSeq[+A] extends Seq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] with IterableFactoryDefaults[A, LinearSeq]

    Base trait for linearly accessed sequences that have efficient `head` and `tail` operations.

    Base trait for linearly accessed sequences that have efficient `head` and `tail` operations. Known subclasses: List, LazyList

40.  trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends SeqOps[A, CC, C]

    Base trait for linear Seq operations

41.  trait LongStepper extends Stepper[Long]

    A Stepper for Longs.

    A Stepper for Longs. See Stepper.

42.  trait Map[K, +V] extends Iterable[(K, V)] with MapOps[K, V, Map, Map[K, V]] with MapFactoryDefaults[K, V, Map, Iterable] with Equals

    Base Map type

43.  trait MapFactory[+CC[_, _]] extends Serializable

44.  trait MapFactoryDefaults[K, +V, +CC[x, y] <: IterableOps[(x, y), Iterable, Iterable[(x, y)]], +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with 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.

    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`.

45.  trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C] extends IterableOps[(K, V), Iterable, C] with PartialFunction[K, V]

    Base Map implementation type

    Base Map implementation type

    K

      Type of keys

    V

      Type of values

    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 a `CC[L, W]`.

    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 a `C`.

46.  trait MapView[K, +V] extends MapOps[K, V, [X, Y]View[(X, Y)], View[(K, V)]] with View[(K, V)]
47.  trait MapViewFactory extends MapFactory[[X, Y]View[(X, Y)]]
48.  trait Seq[+A] extends Iterable[A] with PartialFunction[Int, A] with SeqOps[A, Seq, Seq[A]] with IterableFactoryDefaults[A, Seq] with Equals

    Base trait for sequence collections

    Base trait for sequence collections

    A

      the element type of the collection

49.  trait SeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends IterableFactory[CC]

    CC

      Collection type constructor (e.g. `List`)

50.  trait SeqMap[K, +V] extends Map[K, V] with MapOps[K, V, SeqMap, SeqMap[K, V]] with MapFactoryDefaults[K, V, SeqMap, Iterable]

    A generic trait for ordered maps.

    A generic trait for ordered 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.

51.  trait SeqOps[+A, +CC[_], +C] extends IterableOps[A, CC, C]

    Base trait for Seq operations

    Base trait for Seq operations

    A

      the element type of the collection

    CC

      type constructor of the collection (e.g. `List`, `Set`). Operations returning a collection with a different type of element `B` (e.g. `map`) return a `CC[B]`.

    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 a `C`.

52.  trait SeqView[+A] extends SeqOps[A, View, View[A]] with View[A]
53.  trait Set[A] extends Iterable[A] with SetOps[A, Set, Set[A]] with Equals with IterableFactoryDefaults[A, Set]

    Base trait for set collections.

54.  trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] extends IterableOps[A, CC, C] with (A) => Boolean

    Base trait for set operations

55.  trait SortedIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, Ordering]

    Base trait for companion objects of collections that require an implicit `Ordering`.

    Base trait for companion objects of collections that require an implicit `Ordering`.

    CC

      Collection type constructor (e.g. `SortedSet`)

56.  trait SortedMap[K, +V] extends Map[K, V] with SortedMapOps[K, V, SortedMap, SortedMap[K, V]] with SortedMapFactoryDefaults[K, V, SortedMap, Iterable, Map]

    A Map whose keys are sorted according to a scala.math.Ordering

57.  trait SortedMapFactory[+CC[_, _]] extends Serializable

58.  trait SortedMapFactoryDefaults[K, +V, +CC[x, y] <: Map[x, y] with SortedMapOps[x, y, CC, CC[x, y]] with UnsortedCC[x, y], +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with 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.

    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`.

59.  trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends MapOps[K, V, Map, C] with SortedOps[K, C]
60.  trait SortedOps[A, +C] extends AnyRef

    Base trait for sorted collections

61.  trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]] with SortedSetFactoryDefaults[A, SortedSet, Set]

    Base type of sorted sets

62.  trait SortedSetFactoryDefaults[+A, +CC[X] <: SortedSet[X] with SortedSetOps[X, CC, CC[X]], +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with 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.

    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`.

63.  trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] with SortedOps[A, C]
64.  trait SpecificIterableFactory[-A, +C] extends Factory[A, C]

    A

      Type of elements (e.g. `Int`, `Boolean`, etc.)

    C

      Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.)

65.  trait Stepper[+A] extends AnyRef

    Steppers exist to enable creating Java streams over Scala collections, see scala.jdk.StreamConverters.

    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.

    A

      the element type of the Stepper

66.  sealed trait StepperShape[-T, S <: Stepper[_]] extends AnyRef

    An implicit StepperShape instance is used in the IterableOnce.stepper to return a possibly specialized Stepper `S` according to the element type `T`.

67.  trait StepperShapeLowPriority1 extends StepperShapeLowPriority2
68.  trait StepperShapeLowPriority2 extends AnyRef
69.  trait StrictOptimizedClassTagSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends ClassTagSeqFactory[CC]
70.  trait StrictOptimizedIterableOps[+A, +CC[_], +C] extends IterableOps[A, CC, C]

    Trait that overrides iterable operations to take advantage of strict builders.

    Trait that overrides iterable operations to take advantage of strict builders.

    A

      Elements type

    CC

      Collection type constructor

    C

      Collection type

71.  trait StrictOptimizedLinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with StrictOptimizedLinearSeqOps[A, CC, C]] extends LinearSeqOps[A, CC, C] with StrictOptimizedSeqOps[A, CC, C]
72.  trait StrictOptimizedMapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C] extends MapOps[K, V, CC, C] with StrictOptimizedIterableOps[(K, V), Iterable, C]

    Trait that overrides map operations to take advantage of strict builders.

    Trait that overrides map operations to take advantage of strict builders.

    K

      Type of keys

    V

      Type of values

    CC

      Collection type constructor

    C

      Collection type

73.  trait StrictOptimizedSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends SeqFactory[CC]
74.  trait StrictOptimizedSeqOps[+A, +CC[_], +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.

75.  trait StrictOptimizedSetOps[A, +CC[_], +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.

    Trait that overrides set operations to take advantage of strict builders.

    A

      Elements type

    CC

      Collection type constructor

    C

      Collection type

76.  trait StrictOptimizedSortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C] with StrictOptimizedMapOps[K, V, Map, C]

    Trait that overrides sorted map operations to take advantage of strict builders.

    Trait that overrides sorted map operations to take advantage of strict builders.

    K

      Type of keys

    V

      Type of values

    CC

      Collection type constructor

    C

      Collection type

77.  trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SortedSetOps[A, CC, C] with StrictOptimizedSetOps[A, Set, C]

    Trait that overrides sorted set operations to take advantage of strict builders.

    Trait that overrides sorted set operations to take advantage of strict builders.

    A

      Elements type

    CC

      Collection type constructor

    C

      Collection type

78.  final class StringOps extends AnyVal

    Provides extension methods for strings.

    Provides extension methods for strings.

    Some of these methods treat strings as a plain collection of Chars without any regard for Unicode handling. Unless the user takes Unicode handling in to account or makes sure the strings don't require such handling, these methods may result in unpaired or invalidly paired surrogate code units.

79.  final case class StringView(s: String) extends AbstractIndexedSeqView[Char] with Product with Serializable
80.  trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] with IterableFactoryDefaults[A, View] with Serializable

    Views are collections whose transformation operations are non strict: the resulting elements are evaluated only when the view is effectively traversed (e.g.

    Views are collections whose transformation operations are non strict: the resulting elements are evaluated only when the view is effectively traversed (e.g. using `foreach` or `foldLeft`), or when the view is converted to a strict collection type (using the `to` operation).

81.  abstract class WithFilter[+A, +CC[_]] extends Serializable

    A template trait that contains just the `map`, `flatMap`, `foreach` and `withFilter` methods of trait `Iterable`.

    A template trait that contains just the `map`, `flatMap`, `foreach` and `withFilter` methods of trait `Iterable`.

    A

      Element type (e.g. `Int`)

    CC

      Collection type constructor (e.g. `List`)

    Annotations
      @SerialVersionUID()

### Deprecated Type Members

1.  type ArrayLike[A] = SeqOps[A, Seq, Seq[A]]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use SeqOps (for the methods) or IndexedSeqOps (for fast indexed access) instead of ArrayLike

2.  trait DefaultMap[K, +V] extends Map[K, V]

   A default map which builds a default `immutable.Map` implementation for all transformations.

   A default map which builds a default `immutable.Map` implementation for all transformations.

   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) DefaultMap is no longer necessary; extend Map directly

3.  type GenIterable[+X] = Iterable[X]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

4.  type GenMap[K, +V] = Map[K, V]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

5.  type GenSeq[+X] = Seq[X]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

6.  type GenSet[X] = Set[X]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

7.  type GenTraversable[+X] = Iterable[X]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

8.  type GenTraversableOnce[+X] = IterableOnce[X]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

9.  type SeqLike[A, T] = SeqOps[A, Seq, T]
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use SeqOps instead of SeqLike

10.  type Traversable[+X] = Iterable[X]
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use Iterable instead of Traversable

11.  type TraversableOnce[+X] = IterableOnce[X]
    Annotations
      @deprecated
    Deprecated

      (Since version 2.13.0) Use IterableOnce instead of TraversableOnce

### Value Members

1.  object +:

   An extractor used to head/tail deconstruct sequences.

2.  object :+

   An extractor used to init/last deconstruct sequences.

3.  object AnyStepper
4.  object ArrayOps
5.  object BitSet extends SpecificIterableFactory[Int, BitSet]
   Annotations
     @SerialVersionUID()
6.  object BitSetOps
7.  object BuildFrom extends BuildFromLowPriority1
8.  object ClassTagIterableFactory extends java.io.Serializable
9.  object ClassTagSeqFactory extends java.io.Serializable
10.  object DoubleStepper
11.  object EvidenceIterableFactory extends java.io.Serializable
12.  object Factory
13.  object Hashing
    Attributes
      protected
14.  object IndexedSeq extends Delegate[IndexedSeq]
    Annotations
      @SerialVersionUID()
15.  object IndexedSeqView extends java.io.Serializable
16.  object IntStepper
17.  object Iterable extends Delegate[Iterable]
    Annotations
      @SerialVersionUID()
18.  object IterableFactory extends java.io.Serializable
19.  object IterableOnce
20.  object IterableOps
21.  object Iterator extends IterableFactory[Iterator]
    Annotations
      @SerialVersionUID()
22.  object LazyZip2
23.  object LazyZip3
24.  object LazyZip4
25.  object LinearSeq extends Delegate[LinearSeq]
    Annotations
      @SerialVersionUID()
26.  object LongStepper
27.  object Map extends Delegate[Map]

    This object provides a set of operations to create `Map` values.

    This object provides a set of operations to create `Map` values.

    Annotations
      @SerialVersionUID()
28.  object MapFactory extends java.io.Serializable
29.  object MapOps
30.  object MapView extends MapViewFactory
31.  object Searching
32.  object Seq extends Delegate[Seq]

    This object provides a set of operations to create `Seq` values.

    This object provides a set of operations to create `Seq` values.

    Annotations
      @SerialVersionUID()
33.  object SeqFactory extends java.io.Serializable
34.  object SeqMap extends Delegate[collection.immutable.SeqMap]
35.  object SeqOps
36.  object SeqView extends java.io.Serializable
37.  object Set extends Delegate[Set]

    This object provides a set of operations to create `Set` values.

    This object provides a set of operations to create `Set` values.

    Annotations
      @SerialVersionUID()
38.  object SortedIterableFactory extends java.io.Serializable
39.  object SortedMap extends Delegate[SortedMap]
    Annotations
      @SerialVersionUID()
40.  object SortedMapFactory extends java.io.Serializable
41.  object SortedMapOps
42.  object SortedSet extends Delegate[SortedSet]
    Annotations
      @SerialVersionUID()
43.  object SortedSetOps
44.  object Stepper
45.  object StepperShape extends StepperShapeLowPriority1
46.  object StringOps
47.  object View extends IterableFactory[View]

    This object reifies operations on views as case classes

    This object reifies operations on views as case classes

    Annotations
      @SerialVersionUID()

### Deprecated Value Members

1.  val GenIterable: Iterable.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

2.  val GenMap: Map.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

3.  val GenSeq: Seq.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

4.  val GenSet: Set.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

5.  val GenTraversable: Iterable.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

6.  val GenTraversableOnce: IterableOnce.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Gen* collection types have been removed

7.  val Traversable: Iterable.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use Iterable instead of Traversable

8.  val TraversableOnce: IterableOnce.type
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use IterableOnce instead of TraversableOnce

9.  object JavaConverters extends AsJavaConverters with AsScalaConverters

   A variety of decorators that enable converting between Scala and Java collections using extension methods, `asScala` and `asJava`.

   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)

   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use `scala.jdk.CollectionConverters` instead

### Inherited from AnyRef

### Inherited from Any

### Ungrouped