Трейт scala.collection.Seq

Компаньон объект Seq

трейт Seq[+A] extends PartialFunction[Int, A] with Iterable[A] with GenSeq[A] with GenericTraversableTemplate[A, Seq] with SeqLike[A, Seq[A]]

Базовый трейт для последовательностей.

Последовательности — это особые случаи итерируемых коллекций класса Iterable. В отличие от итерируемых коллекций, последовательности всегда имеют определённый порядок элементов. Последовательности предоставляют метод apply для индексирования. Индексы изменяются от 0 до length последовательности. Последовательности поддерживают ряд методов для поиска вхождений элементов или подпоследовательностей, включая segmentLength, prefixLength, indexWhere, indexOf, lastIndexWhere, lastIndexOf, startsWith, endsWith, indexOfSlice.

Ещё один способ рассматривать последовательность — как PartialFunction от Int значений до типа элемента последовательности. Метод isDefinedAt последовательности возвращает true для интервала от 0 до length.

К последовательностям можно получить доступ в обратном порядке элементов, используя методы reverse и reverseIterator.

Последовательности имеют два основных подтрейта, IndexedSeq и LinearSeq, которые обеспечивают разные гарантии производительности. IndexedSeq обеспечивает быстрый произвольный доступ к элементам и быструю операцию length. LinearSeq обеспечивает быстрый доступ только к первому элементу через head, но также имеет быструю операцию tail.

Источник: Seq.scala

Линейные надтипы

Известные подклассы

Типовые члены

тип Self = Seq[A]

Тип, реализующий этот итерируемый объект

Атрибуты: protected[this]
Определяющие классы: TraversableLike

класс WithFilter extends FilterMonadic[A, Repr]

Класс, поддерживающий отфильтрованные операции. Экземпляры этого класса возвращаются методом withFilter.

Определяющие классы: TraversableLike

Абстрактные значения-члены

абстрактный def apply(idx: Int): A

Выбирает элемент по его индексу в последовательности.

Пример:

scala> val x = List(1, 2, 3, 4, 5)
x: List[Int] = List(1, 2, 3, 4, 5)

scala> x(3)
res1: Int = 4

idx: Индекс для выбора.
возвращает: элемент этой последовательности с индексом idx, где 0 указывает на первый элемент.

Определяющие классы: SeqLike → GenSeqLike
Исключения: IndexOutOfBoundsException, если idx не удовлетворяет 0 <= idx < length.

абстрактный def iterator: Iterator[A]

Создаёт новый итератор по всем элементам, содержащимся в этом итерируемом объекте.

возвращает: новый итератор

Определяющие классы: IterableLike → GenIterableLike

абстрактный def length: Int

Длина последовательности.

Примечание: не завершится для последовательностей бесконечного размера.

Примечание: xs.length и xs.size дают одинаковый результат.

возвращает: количество элементов в этой последовательности.

Определяющие классы: SeqLike → GenSeqLike
Исключения: IllegalArgumentException, если длина последовательности не может быть представлена в Int, например, (-1 to Int.MaxValue).length.

Члены-значения конкретного типа

final def !=(arg0: Any): Boolean

Проверка двух объектов на неравенство.

возвращает: true если !(this == that), иначе false.

Definition Classes: AnyRef → Any

final def ##(): Int

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для числовых типов возвращает значение хэша, согласованное с равенством значений: если две инстанции типа значения сравниваются как true, то ## вернет одинаковое значение хэша для каждой из них. Для null возвращает хэш-код, где null.hashCode вызывает NullPointerException.

возвращает: значение хэша, согласованное с ==

Definition Classes: AnyRef → Any

def +(other: String): String

Неявный: Этот член добавлен неявным преобразованием из Seq[A] в any2stringadd[Seq[A]], выполненное методом any2stringadd в scala.Predef.
Definition Classes: any2stringadd

def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Seq[A], B, That]): That

Возвращает новую коллекцию, содержащую элементы левого операнда, за которыми следуют элементы правого операнда. Тип элементов коллекции — наиболее общий суперкласс, охватывающий типы элементов двух операндов.

B: тип элементов возвращаемой коллекции.
That: класс возвращаемой коллекции. По возможности, That — тот же класс, что и текущий класс коллекции Repr, но это зависит от того, допустим ли тип элемента B для этого класса, что означает, что найден неявный экземпляр типа CanBuildFrom[Repr, B, That].
that: коллекция для добавления.
bf: неявное значение класса CanBuildFrom, которое определяет возвращаемый класс That из текущего типа представления Repr и нового типа элемента B.
возвращает: новую коллекцию типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

Definition Classes: TraversableLike → GenTraversableLike

def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Seq[A], B, That]): That

Как и ++, возвращает новую коллекцию, содержащую элементы левого операнда, за которыми следуют элементы правого операнда.

Отличается от ++ тем, что правый операнд определяет тип результирующей коллекции, а не левый. Мемоника: знак COLon стоит со стороны нового типа COLлекции.

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

Этот перегруз нужен, потому что: для реализации ++: нужно переиспользовать реализацию ++, так как многие коллекции переопределяют его с более эффективными версиями.

Так как у TraversableOnce нет метода ++, нам нужно реализовать его напрямую, но Traversable и ниже могут использовать перегруз.

B: тип элементов возвращаемой коллекции.
That: класс возвращаемой коллекции. По возможности, That — тот же класс, что и текущий класс коллекции Repr, но это зависит от того, допустим ли тип элемента B для этого класса, что означает, что найден неявный экземпляр типа CanBuildFrom[Repr, B, That].
that: коллекция для добавления.
bf: неявное значение класса CanBuildFrom, которое определяет возвращаемый класс That из текущего типа представления Repr и нового типа элемента B.
возвращает: новую коллекцию типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

Definition Classes: TraversableLike

def ++:[B](that: TraversableOnce[B]): Seq[B]

[use case]

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

B: тип элементов возвращаемой коллекции.
that: коллекция для добавления.
возвращает: новый список, который содержит все элементы этого списка, за которыми следуют все элементы that.

Definition Classes: TraversableLike

def +:(elem: A): Seq[A]

[use case]

A copy of the sequence with an element prepended.

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Also, the original sequence is not modified, so you will want to capture the result.

Example:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

elem: the prepended element
returns: a new sequence consisting of elem followed by all elements of this sequence.

Definition Classes: SeqLike → GenSeqLike

def ->[B](y: B): (Seq[A], B)

Implicit: This member is added by an implicit conversion from Seq[A] to ArrowAssoc[Seq[A]] performed by method ArrowAssoc in scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @inline()

def /:[B](z: B)(op: (B, A) ⇒ B): B

Применяет бинарный оператор к начальному значению и всем элементам этого итерируемого объекта или итератора слева направо.

Примечание: /: — это альтернативная запись для foldLeft; z /: xs эквивалентно xs foldLeft z.

Примеры:

Обратите внимание, что функция сворачивания, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен или оператор не ассоциативен и коммутативен.

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого итерируемого объекта или итератора слева направо с начальным значением z слева:

op(...op(op(z, x_1), x_2), ..., x_n)

где x₁, ..., x_n — элементы этого итерируемого объекта или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

def :+(elem: A): Seq[A]

[use case]

A copy of this sequence with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Note: will not terminate for infinite-sized collections.

Example:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

elem: the appended element
returns: a new sequence consisting of all elements of this sequence followed by elem.

Definition Classes: SeqLike → GenSeqLike

def :\[B](z: B)(op: (A, B) ⇒ B): B

Применяет бинарный оператор ко всем элементам этого итерируемого объекта или итератора и начальному значению, двигаясь справа налево.

Примечание: :\ — это альтернативная запись для foldRight; xs :\ z эквивалентно xs foldRight z.

Примечание: не завершится для коллекций бесконечного размера.

Примеры:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

B

тип результата бинарного оператора.

z

начальное значение

op

бинарный оператор

returns

результат вставки op между последовательными элементами этого итерируемого объекта или итератора справа налево с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — элементы этого итерируемого объекта или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

final def ==(arg0: Any): Boolean

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

returns: true если объект-приемник эквивалентен аргументу; false в противном случае.

Definition Classes: AnyRef → Any

def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этого итерируемого объекта или итератора в строку. Записанный текст состоит из строковых представлений (в соответствии с методом toString) всех элементов этого итерируемого объекта или итератора без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

b: строковый буфер, в который добавляются элементы.
returns: строковый буфер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

def addString(b: StringBuilder, sep: String): StringBuilder

Добавляет все элементы этого перебираемого объекта или итератора в строковый билдер с использованием разделителя. Записанный текст состоит из строковых представлений (в соответствии с методом toString) всех элементов этого перебираемого объекта или итератора, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

b: строковый билдер, в который добавляются элементы.
sep: строка-разделитель.
returns: строковый билдер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Добавляет все элементы этого перебираемого объекта или итератора в строковый билдер, используя начальную, конечную и разделительные строки. Записанный текст начинается со строки start и заканчивается строкой end. Внутри строковые представления (в соответствии с методом toString) всех элементов этого перебираемого объекта или итератора разделены строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

b: строковый билдер, в который добавляются элементы.
start: начальная строка.
sep: строка-разделитель.
end: конечная строка.
returns: строковый билдер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

Агрегирует результаты применения оператора к последующим элементам.

Это более общая форма fold и reduce. Она аналогична foldLeft, поскольку не требует, чтобы результат был супертипом типа элемента. Кроме того, она позволяет обрабатывать параллельные коллекции частями и затем объединять промежуточные результаты.

aggregate разбивает перебираемый объект или итератор на разделы и обрабатывает каждый раздел последовательным применением seqop, начиная с z (как foldLeft). Эти промежуточные результаты затем объединяются с помощью combop (как fold). Реализация этой операции может использовать любое количество разделов коллекции (даже 1), поэтому combop может быть вызвана любое количество раз (даже 0).

В качестве примера рассмотрим суммирование целочисленных значений списка символов. Начальное значение для суммы равно 0. Во-первых, seqop преобразует каждый символ ввода в целое число и добавляет его к сумме (раздела). Затем, combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

B: тип накопленных результатов
z: начальное значение для накопленного результата раздела - обычно это будет нейтральный элемент для оператора seqop (например, Nil для конкатенации списков или 0 для суммирования) и может быть вычислено более одного раза
seqop: оператор, используемый для накопления результатов в пределах раздела
combop: ассоциативный оператор, используемый для объединения результатов из разных разделов

Definition Classes: TraversableOnce → GenTraversableOnce

def andThen[C](k: (A) ⇒ C): PartialFunction[Int, C]

Компонует эту частичную функцию с функцией преобразования, которая применяется к результатам этой частичной функции.

C: тип результата функции преобразования.
k: функция преобразования
returns: частичная функция с тем же доменом, что и эта частичная функция, которая отображает аргументы x в k(this(x)).

Definition Classes: PartialFunction → Function1

def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) ⇒ B1): B1

Применяет эту частичную функцию к заданному аргументу, если он содержится в области определения функции. Применяет функцию по умолчанию, когда эта частичная функция не определена.

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех литералов частичных функций компилятор генерирует реализацию applyOrElse, которая избегает двойного вычисления совпадений шаблонов и условий. Это делает applyOrElse основой для эффективной реализации во многих операциях и сценариях, таких как:

orElse

andThen

apply

isDefinedAt

lift

unlift

runWith

Для классов частичных функций, отличных от литералов, с нетривиальным методом isDefinedAt, рекомендуется переопределить applyOrElse с пользовательской реализацией, которая избегает двойного вычисления isDefinedAt. Это может привести к лучшей производительности и более предсказуемому поведению относительно побочных эффектов.

x: аргумент функции
default: функция по умолчанию
returns: результат применения этой функции или функции по умолчанию.

Definition Classes: PartialFunction
Since: 2.10

final def asInstanceOf[T0]: T0

Преобразует объект-получатель к типу T0.

Обратите внимание, что успех преобразования во время выполнения зависит от семантики стирания Scala. Следовательно, выражение 1.asInstanceOf[String] выбросит исключение ClassCastException во время выполнения, а выражение List(1).asInstanceOf[List[String]] — нет. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, соответствуют ли элементы списка требуемому типу.

возвращает: объект-получатель.

Определяющие классы: Any
Исключения: ClassCastException, если объект-получатель не является экземпляром стираемого типа T0.

def canEqual(that: Any): Boolean

Метод, вызываемый из методов сравнения на равенство, чтобы пользовательские подклассы могли отказать в равенстве с другими коллекциями того же типа.

that: Объект, с которым эта итерируемая коллекция должна быть сравнена.
возвращает: true, если эта итерируемая коллекция может быть равна that, false в противном случае. При проверке учитываются только типы объектов во время выполнения, но игнорируются их элементы.

Определяющие классы: IterableLike → Equals

def clone(): AnyRef

Создаёт копию объекта-получателя.

По умолчанию реализация метода clone зависит от платформы.

возвращает: копию объекта-получателя.

Атрибуты: protected[lang]
Определяющие классы: AnyRef
Аннотации: @throws( ... ) @native()
Примечание: не определён в SLS как член AnyRef

def collect[B](pf: PartialFunction[A, B]): Seq[B]

[use case]

Создаёт новую коллекцию, применяя частичную функцию ко всем элементам этого последовательного типа, для которых функция определена.

B: тип элементов возвращаемой коллекции.
pf: частичная функция, которая фильтрует и отображает последовательность.
возвращает: новую последовательность, полученную путём применения данной частичной функции pf к каждому элементу, для которого она определена, и сбора результатов. Порядок элементов сохраняется.

Определяющие классы: TraversableLike → GenTraversableLike

def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

Находит первый элемент в последовательности или итераторе, для которого заданная частичная функция определена, и применяет частичную функцию к нему.

Примечание: может не завершаться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип коллекции не упорядочен.

pf: частичная функция
возвращает: значение Option, содержащее результат применения pf к первому элементу, для которого она определена, или None если такового нет.

Определяющие классы: TraversableOnce

def combinations(n: Int): Iterator[Seq[A]]

Итерирует по сочетаниям. _Сочетание_ длины n — это подпоследовательность исходной последовательности, элементы которой взяты в порядке. Таким образом, "xy" и "yy" — оба сочетания длины 2 из "xyy", но "yx" — нет. Если существует более одного способа генерировать одну и ту же подпоследовательность, будет возвращён только один. Какой из трёх способов будет выбран, является деталью реализации и не определён.

Например, "xyyy" имеет три различных способа генерировать "xy", в зависимости от того, какой первый, второй или третий "y" выбран. Однако, поскольку все они идентичны, будет выбран только один. Какой из трёх будет выбран, зависит от реализации и не определяется.

возвращает: Итератор, который проходит по возможным сочетаниям из n элементов этой последовательности.

Определяющие классы: SeqLike

def companion: GenericCompanion[Seq]

Компаньон-объект-фабрика, создающий экземпляры класса Seq. (или его Iterable суперкласса, где класс Seq не является Seq.)

Определяющие классы: Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate

def compose[A](g: (A) ⇒ Int): (A) ⇒ A

Компонует два экземпляра Function1 в новую Function1, при этом эта функция применяется последней.

A: тип, к которому можно применить функцию g
g: функция A => T1
возвращает: новая функция f такая, что f(x) == apply(g(x))

Определяющие классы: Function1
Аннотации: @unspecialized()

def contains[A1 >: A](elem: A1): Boolean

Проверяет, содержит ли этот последовательность заданное значение в качестве элемента.

Примечание: может не завершиться для бесконечных коллекций.

elem: элемент для проверки.
returns: true если в этой последовательности есть элемент, равный (как определено ==) elem, false в противном случае.

Definition Classes: SeqLike

def containsSlice[B](that: GenSeq[B]): Boolean

Проверяет, содержит ли эта последовательность заданную последовательность в качестве среза.

Примечание: может не завершиться для бесконечных коллекций.

that: последовательность для проверки
returns: true если эта последовательность содержит срез с теми же элементами, что и that, в противном случае false.

Definition Classes: SeqLike

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

[use case]

Копирует элементы этой последовательности в массив. Заполняет данный массив xs максимум len элементами этой последовательности, начиная с позиции start. Копирование остановится, как только будет достигнут конец текущей последовательности, или конец целевого массива, или len элементов были скопированы.

Примечание: не завершится для бесконечных коллекций.

xs: массив для заполнения.
start: начальный индекс.
len: максимальное количество копируемых элементов.

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def copyToArray(xs: Array[A]): Unit

[use case]

Копирует элементы этой последовательности в массив. Заполняет данный массив xs значениями этой последовательности. Копирование остановится, как только будет достигнут конец текущей последовательности или конец целевого массива.

Примечание: не завершится для бесконечных коллекций.

xs: массив для заполнения.

Definition Classes: TraversableOnce → GenTraversableOnce

def copyToArray(xs: Array[A], start: Int): Unit

[use case]

Копирует элементы этой последовательности в массив. Заполняет данный массив xs значениями этой последовательности, начиная с индекса start. Копирование остановится, как только будет достигнут конец текущей последовательности или конец целевого массива.

Примечание: не завершится для бесконечных коллекций.

xs: массив для заполнения.
start: начальный индекс.

Definition Classes: TraversableOnce → GenTraversableOnce

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

Копирует все элементы этой последовательности или итератора в буфер.

Примечание: не завершится для бесконечных коллекций.

dest: Буфер, в который копируются элементы.

Definition Classes: TraversableOnce

def corresponds[B](that: GenSeq[B])(p: (A, B) ⇒ Boolean): Boolean

Проверяет, удовлетворяет ли каждый элемент этой последовательности соответствующему элементу другой последовательности, удовлетворяя условию предиката.

B: тип элементов that
that: другая последовательность
p: предикат проверки, который связывает элементы из обеих последовательностей
returns: true если обе последовательности имеют одинаковую длину и p(x, y) является true для всех соответствующих элементов x этой последовательности и y that, в противном случае false.

Definition Classes: SeqLike → GenSeqLike

def count(p: (A) ⇒ Boolean): Int

Подсчитывает количество элементов в последовательности или итераторе, удовлетворяющих предикату.

p: предикат, используемый для проверки элементов.
returns: количество элементов, удовлетворяющих предикату p.

Definition Classes: TraversableOnce → GenTraversableOnce

def diff(that: Seq[A]): Seq[A]

[use case]

Вычисляет разность мультимножеств между этой последовательностью и другой последовательностью.

Примечание: не будет завершаться для коллекций бесконечного размера.

that: последовательность элементов для удаления
returns: новая последовательность, содержащая все элементы этой последовательности, за исключением некоторых вхождений элементов, которые также появляются в that. Если значение элемента x встречается n раз в that, то первые n вхождений x не будут частью результата, но любые последующие вхождения будут.

Definition Classes: SeqLike → GenSeqLike

def distinct: Seq[A]

Создаёт новую последовательность из этой последовательности без дублирующих элементов.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: Новая последовательность, содержащая первое вхождение каждого элемента этой последовательности.

Definition Classes: SeqLike → GenSeqLike

def drop(n: Int): Seq[A]

Выбирает все элементы, кроме первых n.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

n: количество элементов для удаления из этой итерируемой коллекции.
returns: итерируемая коллекция, состоящая из всех элементов этой итерируемой коллекции, кроме первых n элементов, или же пустая итерируемая коллекция, если у этой итерируемой коллекции меньше, чем n элементов. Если n отрицательно, не удалять никаких элементов.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def dropRight(n: Int): Seq[A]

Выбирает все элементы, кроме последних n.

n: Количество элементов для взятия
returns: итерируемая коллекция, состоящая из всех элементов этой итерируемой коллекции, кроме последних n элементов, или же пустая итерируемая коллекция, если у этой итерируемой коллекции меньше, чем n элементов.

Definition Classes: IterableLike

def dropWhile(p: (A) ⇒ Boolean): Seq[A]

Удаляет самую длинную префиксную часть элементов, удовлетворяющих предикату.

returns: самый длинный суффикс этой итерируемой коллекции, первый элемент которого не удовлетворяет предикату p.

Definition Classes: TraversableLike → GenTraversableLike

def endsWith[B](that: GenSeq[B]): Boolean

Проверяет, заканчивается ли эта последовательность данной последовательностью.

Примечание: не будет завершаться для коллекций бесконечного размера.

that: последовательность для проверки
returns: true если эта последовательность имеет that в качестве суффикса, false в противном случае.

Definition Classes: SeqLike → GenSeqLike

def ensuring(cond: (Seq[A]) ⇒ Boolean, msg: ⇒ Any): Seq[A]

Неявный: Этот член добавлен неявным преобразованием из Seq[A] в Ensuring[Seq[A]], выполненное методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (Seq[A]) ⇒ Boolean): Seq[A]

Неявный: Этот член добавлен неявным преобразованием из Seq[A] в Ensuring[Seq[A]], выполненное методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): Seq[A]

Неявный: Этот член добавлен неявным преобразованием из Seq[A] в Ensuring[Seq[A]], выполненное методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean): Seq[A]

Неявный: Этот член добавлен с помощью неявного преобразования из Seq[A] в Ensuring[Seq[A]] с помощью метода Ensuring в scala.Predef.
Определяющие классы: Ensuring

final def eq(arg0: AnyRef): Boolean

Проверяет, является ли аргумент (that) ссылкой на объект-приемник (this).

Метод eq реализует отношение эквивалентности отношение эквивалентности для непустых экземпляров AnyRef, и обладает тремя дополнительными свойствами:

x

y

AnyRef

x.eq(y)

true

false

x

AnyRef

x.eq(null)

null.eq(x)

false

null.eq(null)

true

При переопределении методов equals или hashCode важно обеспечить согласованность их поведения с равенством ссылок. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны иметь одинаковое значение хеша (o1.hashCode == o2.hashCode).

возвращает: true если аргумент является ссылкой на объект-получатель; false в противном случае.

Определяющие классы: AnyRef

def equals(that: Any): Boolean

Метод equals для произвольных последовательностей. Сравнивает эту последовательность с другим объектом.

that: Объект для сравнения с последовательностью
возвращает: true если that — это последовательность, имеющая те же элементы, что и эта последовательность в том же порядке, false в противном случае

Определяющие классы: GenSeqLike → Equals → Any

def exists(p: (A) ⇒ Boolean): Boolean

Проверяет, выполняется ли предикат для хотя бы одного элемента в этом итерируемом наборе коллекций.

Примечание: может не завершиться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
возвращает: false если этот итерируемый набор коллекций пуст, в противном случае true если данный предикат p выполняется для некоторых элементов этого итерируемого набора коллекций, в противном случае false

Определяющие классы: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def filter(p: (A) ⇒ Boolean): Seq[A]

Выбирает все элементы этой итерируемой коллекции, которые удовлетворяют предикату.

p: предикат, используемый для проверки элементов.
возвращает: новая итерируемая коллекция, состоящая из всех элементов этой итерируемой коллекции, удовлетворяющих данному предикату p. Порядок элементов сохраняется.

Определяющие классы: TraversableLike → GenTraversableLike

def filterNot(p: (A) ⇒ Boolean): Seq[A]

Выбирает все элементы этой итерируемой коллекции, которые не удовлетворяют предикату.

p: предикат, используемый для проверки элементов.
возвращает: новая итерируемая коллекция, состоящая из всех элементов этой итерируемой коллекции, которые не удовлетворяют данному предикату p. Порядок элементов сохраняется.

Определяющие классы: TraversableLike → GenTraversableLike

def finalize(): Unit

Вызывается сборщиком мусора на объекте-получателе, когда больше нет ссылок на объект.

Детали о том, когда и как вызывается метод finalize, а также взаимодействие между finalize и нелокальными возвратами и исключениями, зависят от платформы.

Атрибуты: protected[lang]
Определяющие классы: AnyRef
Аннотации: @throws( classOf[java.lang.Throwable] )
Примечание: не указано SLS в качестве члена AnyRef

def find(p: (A) ⇒ Boolean): Option[A]

Находит первый элемент итерируемой коллекции, удовлетворяющий предикату, если такой элемент существует.

Примечание: может не завершиться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не является упорядоченным.

p: предикат, используемый для проверки элементов.
возвращает: значение Option, содержащее первый элемент в итерируемой коллекции, удовлетворяющий p, или None если такой элемент не существует.

Определяющие классы: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Seq[B]

[use case]

Создаёт новую коллекцию, применяя функцию ко всем элементам этой последовательности и используя элементы полученных коллекций.

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующей коллекции определяется статическим типом последовательности. Это может иногда приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новая последовательность, полученная путём применения заданной функции, возвращающей коллекцию f к каждому элементу этой последовательности и конкатенации результатов.

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def flatten[B]: Seq[B]

[use case]

Преобразует эту последовательность коллекций-перебираемых объектов в последовательность, образованную элементами этих коллекций-перебираемых объектов.

Тип результирующей коллекции будет определяться статическим типом последовательности. Например:

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

B: тип элементов каждой коллекции-перебираемого объекта.
returns: новая последовательность, полученная путём конкатенации всех последовательностей элементов.

Definition Classes: GenericTraversableTemplate

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

Складывает элементы этого перебираемого объекта или итератора, используя заданный ассоциативный бинарный оператор.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

Примечание: не завершится для коллекций бесконечного размера.

A1: параметр типа для бинарного оператора, являющийся надтипом A.
z: нейтральный элемент для операции слияния; может быть добавлен к результату любое количество раз, и не должен изменять результат (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения).
op: бинарный оператор, который должен быть ассоциативным.
returns: результат применения оператора слияния op между всеми элементами и z, или z если этот перебираемый объект или итератор пустой.

Definition Classes: TraversableOnce → GenTraversableOnce

def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

Применяет бинарный оператор к начальному значению и всем элементам этого перебираемого объекта или итератора слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен или оператор не ассоциативен и не коммутативен.

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого перебираемого объекта или итератора слева направо с начальным значением z слева:

op(...op(z, x_1), x_2, ..., x_n)

где x₁, ..., x_n — элементы этого перебираемого объекта или итератора. Возвращает z если этот перебираемый объект или итератор пуст.

Definition Classes: TraversableOnce → GenTraversableOnce

def foldRight[B](z: B)(op: (A, B) ⇒ B): B

Применяет бинарный оператор ко всем элементам этой итерируемой коллекции и начальному значению, двигаясь справа налево.

Примечание: не завершится для коллекций бесконечного размера.

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой итерируемой коллекции, двигаясь справа налево, с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — элементы этой итерируемой коллекции. Возвращает z если эта итерируемая коллекция пустая.

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

def forall(p: (A) ⇒ Boolean): Boolean

Проверяет, выполняется ли предикат для всех элементов этой итерируемой коллекции.

Примечание: может не завершиться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
returns: true если эта итерируемая коллекция пуста или заданный предикат p выполняется для всех элементов этой итерируемой коллекции, в противном случае false.

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def foreach(f: (A) ⇒ Unit): Unit

[use case]

Применяет функцию f ко всем элементам этой последовательности.

Примечание: этот метод является основой для реализации большинства других операций над массивом. Подклассы должны переопределять этот метод, если существует более эффективный способ реализации.

f: функция, которая применяется к каждому элементу для получения побочного эффекта. Результат функции f игнорируется.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def formatted(fmtstr: String): String

Возвращает строку, отформатированную в соответствии с заданной format строкой. Форматные строки соответствуют String.format (@see java.lang.String.format).

Неявный: Этот член добавляется неявным преобразованием из Seq[A] в StringFormat[Seq[A]], выполненное методом StringFormat в scala.Predef.
Definition Classes: StringFormat
Аннотации: @inline()

def genericBuilder[B]: Builder[B, Seq[B]]

Неявный генератор, создающий экземпляры Traversable с произвольными типами элементов.

Definition Classes: GenericTraversableTemplate

final def getClass(): Class[_]

Возвращает представление класса объекта во время выполнения.

возвращает: объект класса, соответствующий типу получателя во время выполнения.

Definition Classes: AnyRef → Any
Аннотации: @native()

def groupBy[K](f: (A) ⇒ K): immutable.Map[K, Seq[A]]

Разбивает эту коллекцию на карту коллекций в соответствии с функцией-дискриминатором.

Примечание: этот метод не переопределяется представлениями. Это означает, что при применении к представлению он всегда принудительно вычисляет представление и возвращает новую коллекцию.

K

тип ключей, возвращаемых функцией-дискриминатором.

f

функция-дискриминатор.

возвращает

Карта от ключей к коллекциям, которая удовлетворяет следующему инварианту:

(xs groupBy f)(k) = xs filter (x => f(x) == k)

То есть каждый ключ k привязан к коллекции элементов x для которых f(x) равно k.

Definition Classes: TraversableLike → GenTraversableLike

def grouped(size: Int): Iterator[Seq[A]]

Разбивает элементы на итерабельные коллекции фиксированного размера.

size: количество элементов в каждой группе
возвращает: Итератор, генерирующий итерабельные коллекции размера size, за исключением последней, которая будет меньше размера size если элементы не делятся на него без остатка.

Definition Classes: IterableLike
См. также: scala.collection.Iterator, метод grouped

def hasDefiniteSize: Boolean

Проверяет, известен ли конечный размер этой итерабельной коллекции. Все строгие коллекции известны своим конечным размером. Для нестрогой коллекции, такой как Stream, предикат возвращает true если все элементы были вычислены. Он возвращает false если поток еще не дошел до конца. Непустые итераторы обычно возвращают false даже если они были созданы из коллекции с известным конечным размером.

Примечание: многие методы коллекции не будут работать с коллекциями бесконечных размеров. Типичный режим отказа — бесконечный цикл. Эти методы всегда пытаются пройтись, не проверяя предварительно, что hasDefiniteSize возвращает true. Однако проверка hasDefiniteSize может обеспечить гарантию, что размер определен и бесконечная итерация не является проблемой.

возвращает: true если размер этой коллекции известен и конечен, false в противном случае.

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

Хеш-коды для GenSeq генерируют значение из хеш-кодов всех элементов общей последовательности.

возвращает: значение хеш-кода для этого объекта.

Definition Classes: GenSeqLike → Any

def head: A

Выбирает первый элемент этого итерируемого набора.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен.

возвращает: первый элемент этого итерируемого набора.

Определяющие классы: IterableLike → TraversableLike → GenTraversableLike
Исключения: NoSuchElementException, если итерируемый набор пуст.

def headOption: Option[A]

Необязательно выбирает первый элемент.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен.

возвращает: первый элемент этого итерируемого набора, если он не пуст, None если он пуст.

Определяющие классы: TraversableLike → GenTraversableLike

def indexOf(elem: A, from: Int): Int

[use case]

Находит индекс первого вхождения некоторого значения в этой последовательности после или на определенном начальном индексе.

Примечание: может не завершаться для наборов бесконечного размера.

elem: значение элемента для поиска.
from: начальный индекс
возвращает: индекс >= from первого элемента этой последовательности, который равен (как определено ==) elem, или -1, если такого нет.

Определяющие классы: GenSeqLike

def indexOf(elem: A): Int

[use case]

Находит индекс первого вхождения некоторого значения в этой последовательности.

Примечание: может не завершаться для наборов бесконечного размера.

elem: значение элемента для поиска.
возвращает: индекс первого элемента этой последовательности, который равен (как определено ==) elem, или -1, если такого нет.

Определяющие классы: GenSeqLike

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

Находит первый индекс после или на начальном индексе, где эта последовательность содержит заданную последовательность как срез.

Примечание: может не завершаться для наборов бесконечного размера.

that: последовательность для проверки
from: начальный индекс
возвращает: первый индекс >= from такой, что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1 если такой подпоследовательности не существует.

Определяющие классы: SeqLike

def indexOfSlice[B >: A](that: GenSeq[B]): Int

Находит первый индекс, где эта последовательность содержит заданную последовательность как срез.

Примечание: может не завершаться для наборов бесконечного размера.

that: последовательность для проверки
возвращает: первый индекс такой, что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1 если такой подпоследовательности не существует.

Определяющие классы: SeqLike

def indexWhere(p: (A) ⇒ Boolean, from: Int): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату после или на определенном начальном индексе.

Примечание: может не завершаться для наборов бесконечного размера.

p: предикат, используемый для проверки элементов.
from: начальный индекс
возвращает: индекс >= from первого элемента этой последовательности, удовлетворяющего предикату p, или -1, если такого нет.

Определяющие классы: SeqLike → GenSeqLike

def indexWhere(p: (A) ⇒ Boolean): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату.

Примечание: может не завершаться для наборов бесконечного размера.

p: предикат, используемый для проверки элементов.
возвращает: индекс первого элемента этой общей последовательности, удовлетворяющего предикату p, или -1, если такого нет.

Определяющие классы: GenSeqLike

def indices: immutable.Range

Создает диапазон всех индексов этой последовательности.

возвращает: значение Range от 0 до значения, на единицу меньшего длины этой последовательности.

Определяющие классы: SeqLike

def init: Seq[A]

Выбирает все элементы, кроме последнего.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен.

возвращает: перебираемый набор, состоящий из всех элементов этого перебираемого набора, кроме последнего.

Определяющие классы: TraversableLike → GenTraversableLike
Исключения: UnsupportedOperationException, если набор перебираемых элементов пуст.

def inits: Iterator[Seq[A]]

Итерирует по начальным частям этого перебираемого набора. Первое значение будет этим перебираемым набором, а последнее — пустым перебираемым набором, а промежуточные значения — результаты последовательных применений init.

возвращает: итератор по всем начальным частям этого перебираемого набора

Определяющие классы: TraversableLike

def intersect(that: Seq[A]): Seq[A]

[use case]

Вычисляет пересечение мультимножеств между этой последовательностью и другой последовательностью.

Примечание: может не завершиться для бесконечных наборов.

that: последовательность элементов для пересечения.
возвращает: новая последовательность, содержащая все элементы этой последовательности, которые также встречаются в that. Если значение элемента x встречается n раз в that, то первые n вхождений x будут сохранены в результате, но любые последующие вхождения будут опущены.

Определяющие классы: SeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

Проверяет, содержит ли эта общая последовательность данный индекс.

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

idx: индекс для проверки
возвращает: true если эта общая последовательность содержит элемент в позиции idx, false в противном случае.

Определяющие классы: GenSeqLike

def isEmpty: Boolean

Проверяет, является ли эта последовательность пустой.

возвращает: true если последовательность не содержит элементов, false в противном случае.

Определяющие классы: SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

Проверяет, является ли динамический тип объекта получателя T0.

Обратите внимание, что результат теста зависит от правил стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, а выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, так как аргумент типа стирается во время компиляции, проверить, являются ли элементы списка указанного типа, нельзя.

возвращает: true если объект получателя является экземпляром стирания типа T0; false в противном случае.

Определяющие классы: Any

final def isTraversableAgain: Boolean

Проверяет, можно ли повторно пройти по этому перебираемому набору.

возвращает: true

Определяющие классы: TraversableLike → GenTraversableLike → GenTraversableOnce

def last: A

Выбирает последний элемент.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен.

возвращает: Последний элемент этого перебираемого набора.

Определяющие классы: TraversableLike → GenTraversableLike
Исключения: NoSuchElementException Если перебираемый набор пуст.

def lastIndexOf(elem: A, end: Int): Int

[use case]

Находит индекс последнего вхождения некоторого значения в этой последовательности до или на заданном индексе конца.

elem: значение элемента, для которого нужно выполнить поиск.
end: индекс конца.
возвращает: индекс <= end последнего элемента этой последовательности, который равен (как определяется ==) elem, или -1, если такого нет.

Определяющие классы: GenSeqLike

def lastIndexOf(elem: A): Int

[use case]

Находит индекс последнего вхождения некоторого значения в этой последовательности.

Примечание: не завершится для бесконечных последовательностей.

elem: значение элемента, для которого нужно выполнить поиск.
возвращает: индекс последнего элемента этой последовательности, который равен (как определяется ==) elem, или -1, если такого нет.

Определяющие классы: GenSeqLike

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

Находит последний индекс перед или на заданном индексе конца, где эта последовательность содержит заданную последовательность в качестве среза.

that: последовательность для проверки
end: индекс конца
returns: последний индекс <= end, такой что элементы этой последовательности, начинающиеся с этого индекса, соответствуют элементам последовательности that, или -1, если такой подпоследовательности не существует.

Definition Classes: SeqLike

def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

Находит последний индекс, где эта последовательность содержит заданную последовательность в качестве среза.

Примечание: не будет завершаться для коллекций бесконечного размера.

that: последовательность для проверки
returns: последний индекс, такой что элементы этой последовательности, начинающиеся с этого индекса, соответствуют элементам последовательности that, или -1, если такой подпоследовательности не существует.

Definition Classes: SeqLike

def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату перед или на заданном индексе конца.

p: предикат, используемый для проверки элементов.
returns: индекс <= end последнего элемента этой последовательности, удовлетворяющего предикату p, или -1, если такового нет.

Definition Classes: SeqLike → GenSeqLike

def lastIndexWhere(p: (A) ⇒ Boolean): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату.

Примечание: не будет завершаться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
returns: индекс последнего элемента этой общей последовательности, удовлетворяющего предикату p, или -1, если такового нет.

Definition Classes: GenSeqLike

def lastOption: Option[A]

Возвращает последний элемент, если он существует.

returns: последний элемент этой коллекции traversable, если она не пустая, None если она пустая.

Definition Classes: TraversableLike → GenTraversableLike

def lengthCompare(len: Int): Int

Сравнивает длину этой последовательности со значением проверки.

len

значение проверки, которое сравнивается с длиной.

returns

Значение x, где

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Метод, как он реализован здесь, не вызывает length напрямую; его время выполнения составляет O(length min len) вместо O(length). Метод следует перезаписать, если вычисление length является недорогим.

Definition Classes: SeqLike

def lift: (Int) ⇒ Option[A]

Преобразует эту частичную функцию в обычную функцию, возвращающую результат Option.

returns: функция, которая принимает аргумент x к Some(this(x)), если this определено для x, и к None в противном случае.

Definition Classes: PartialFunction
См. также: Function.unlift

def map[B](f: (A) ⇒ B): Seq[B]

[пример использования]

Создает новую коллекцию, применяя функцию ко всем элементам этой последовательности.

B: тип элемента возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новая последовательность, полученная в результате применения данной функции f к каждому элементу этой последовательности и сбора результатов.

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[пример использования]

Находит наибольший элемент.

returns: наибольший элемент этой последовательности.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пуста.

def maxBy[B](f: (A) ⇒ B): A

[use case]

Находит первый элемент, который возвращает наибольшее значение, измеренное функцией f.

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой последовательности с наибольшим значением, измеренным функцией f.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пустая.

def min: A

[use case]

Находит наименьший элемент.

returns: наименьший элемент этой последовательности

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пустая.

def minBy[B](f: (A) ⇒ B): A

[use case]

Находит первый элемент, который возвращает наименьшее значение, измеренное функцией f.

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой последовательности с наименьшим значением, измеренным функцией f.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException если эта последовательность пустая.

def mkString: String

Отображает все элементы этого traversable или итератора в строке.

returns: строковое представление этого traversable или итератора. В результирующей строке строковые представления (с помощью метода toString) всех элементов этого traversable или итератора следуют друг за другом без разделителя.

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

Отображает все элементы этого traversable или итератора в строке с использованием разделителя.

sep: строка-разделитель.
returns: строковое представление этого traversable или итератора. В результирующей строке строковые представления (с помощью метода toString) всех элементов этого traversable или итератора разделяются строкой sep.

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(start: String, sep: String, end: String): String

Отображает все элементы этого traversable или итератора в строку с использованием начальной, конечной и разделительных строк.

start: начальная строка.
sep: строка-разделитель.
end: конечная строка.
returns: строковое представление этого traversable или итератора. Результирующая строка начинается со строки start и заканчивается строкой end. Внутри строковые представления (с помощью метода toString) всех элементов этого traversable или итератора разделяются строкой sep.

Definition Classes: TraversableOnce → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

Эквивалентно !(this eq that).

returns: true если аргумент не является ссылкой на объект-получатель; false в противном случае.

Definition Classes: AnyRef

def newBuilder: Builder[A, Seq[A]]

Построитель, который создаёт экземпляры типа Traversable[A]

Attributes: protected[this]
Definition Classes: GenericTraversableTemplate → HasNewBuilder

def nonEmpty: Boolean

Проверяет, не пуст ли traversable или итератор.

returns: true если traversable или итератор содержит по крайней мере один элемент, false в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

final def notify(): Unit

Разбуждает единственную нить, ждущую монитора объекта-получателя.

Definition Classes: AnyRef
Annotations: @native()
Примечание: не указано в SLS как член AnyRef

final def notifyAll(): Unit

Разбуживает все потоки, ожидающие монитора объекта-получателя.

Definition Classes: AnyRef
Annotations: @native()
Note: не указано SLS как член AnyRef

def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Компонует эту частичную функцию с резервной частичной функцией, которая применяется там, где эта частичная функция не определена.

A1: тип аргумента резервной функции
B1: тип результата резервной функции
that: резервная функция
returns: частичная функция, у которой область значений является объединением областей значений этой частичной функции и that. Результирующая частичная функция принимает x к this(x), где this определена, и к that(x) в противном случае.

Definition Classes: PartialFunction

def padTo(len: Int, elem: A): Seq[A]

[use case]

Копия этой последовательности со значением элемента, добавленным до достижения заданной целевой длины.

len: целевая длина
elem: значение заполнения
returns: новая последовательность, состоящая из всех элементов этой последовательности, за которой следует минимальное количество вхождений elem, чтобы результирующая последовательность имела длину не менее len.

Definition Classes: SeqLike → GenSeqLike

def par: ParSeq[A]

Возвращает параллельную реализацию этого набора.

Для большинства типов коллекций этот метод создает новую параллельную коллекцию, копируя все элементы. Для этих коллекций метод par занимает линейное время. Изменяемые коллекции в этой категории не создают изменяемую параллельную коллекцию, которая имеет тот же базовый набор данных, поэтому изменения в одной коллекции не будут отражены в другой.

Конкретные коллекции (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая разделяет те же базовые данные. Для этих коллекций par занимает постоянное или подлинейное время.

Все параллельные коллекции возвращают ссылку на себя.

returns: параллельная реализация этого набора

Definition Classes: Parallelizable

def parCombiner: Combiner[A, ParSeq[A]]

Реализация по умолчанию par использует комбинатор, предоставленный этим методом, для создания новой параллельной коллекции.

returns: комбинатор для параллельной коллекции типа ParRepr

Attributes: protected[this]
Definition Classes: SeqLike → TraversableLike → Parallelizable

def partition(p: (A) ⇒ Boolean): (Seq[A], Seq[A])

Разделяет этот обобщённый набор на два обобщённых набора в соответствии с предикатом.

p: предикат для разделения.
returns: пара обобщённых наборов: первый обобщённый набор состоит из всех элементов, удовлетворяющих предикату p, а второй — из всех элементов, которые этого не удовлетворяют. Относительный порядок элементов в результирующих обобщённых наборах такой же, как и в исходном обобщённом наборе.

Definition Classes: TraversableLike → GenTraversableLike

def patch(from: Int, that: GenSeq[A], replaced: Int): Seq[A]

[use case]

Возвращает новый набор, где фрагмент элементов в этом наборе заменяется другим набором.

from: индекс первого заменяемого элемента
replaced: количество элементов для удаления в исходном наборе
returns: новый набор, состоящий из всех элементов этого набора, за исключением того, что replaced элементы, начиная с from, заменяются на patch.

Definition Classes: SeqLike → GenSeqLike

def permutations: Iterator[Seq[A]]

Итерация по уникальным перестановкам.

returns: Итератор, проходящий по уникальным перестановкам этой последовательности.

Definition Classes: SeqLike

def prefixLength(p: (A) ⇒ Boolean): Int

Возвращает длину самого длинного префикса, элементы которого удовлетворяют заданному предикату.

Примечание: может не завершаться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
возвращает: длину самого длинного префикса этой общей последовательности, в которой каждый элемент сегмента удовлетворяет предикату p.

Определяющие классы: GenSeqLike

def product: A

[use case]

Перемножает элементы этой коллекции.

возвращает: произведение всех элементов в этой последовательности чисел типа Int. Вместо Int, может быть использован любой другой тип T с неявным Numeric[T] реализацией, который может использоваться как тип элементов последовательности и как тип возвращаемого значения product. Примеры таких типов: Long, Float, Double, BigInt.

Определяющие классы: TraversableOnce → GenTraversableOnce

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

Применяет заданный ассоциативный бинарный оператор к элементам этой коллекции или итератора.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

A1: Параметр типа для бинарного оператора, надтипом A.
op: Бинарный оператор, который должен быть ассоциативным.
возвращает: Результат применения оператора op между всеми элементами, если коллекция или итератор не пустые.

Определяющие классы: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта коллекция или итератор пустые.

def reduceLeft[B >: A](op: (B, A) ⇒ B): B

Применяет бинарный оператор ко всем элементам этой коллекции или итератора слева направо.

Примечание: не будет завершаться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен или оператор не ассоциативен и не коммутативен.

B

тип результата бинарного оператора.

op

бинарный оператор.

возвращает

результат вставки op между последовательными элементами этой коллекции или итератора слева направо:

op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)

где x₁, ..., x_n — элементы этой коллекции или итератора.

Определяющие классы: TraversableOnce
Исключения: UnsupportedOperationException, если эта коллекция или итератор пустые.

def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

Опционально применяет бинарный оператор ко всем элементам этой коллекции или итератора слева направо.

Примечание: не будет завершаться для коллекций бесконечного размера.

B: тип результата бинарного оператора.
op: бинарный оператор.
возвращает: значение Option, содержащее результат reduceLeft(op), если эта коллекция или итератор не пустые, None в противном случае.

Определяющие классы: TraversableOnce → GenTraversableOnce

def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

Применяет заданный ассоциативный бинарный оператор к элементам этой коллекции или итератора, если они есть.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

A1: Параметр типа для бинарного оператора, надтипом A.
op: Бинарный оператор, который должен быть ассоциативным.
возвращает: Значение Option, содержащее результат применения оператора op между всеми элементами, если коллекция не пустая, и None в противном случае.

Определяющие классы: TraversableOnce → GenTraversableOnce

def reduceRight[B >: A](op: (A, B) ⇒ B): B

Применяет бинарный оператор ко всем элементам этого итерируемого набора, слева направо.

Примечание: не будет завершаться для бесконечных наборов.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен или оператор не является ассоциативным и коммутативным.

B

тип результата бинарного оператора.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого итерируемого набора, слева направо:

op(x_1, op(x_2, ..., op(x_{n-1}, x_n)...))

где x₁, ..., x_n — элементы этого итерируемого набора.

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот итерируемый набор пуст.

def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

При необходимости применяет бинарный оператор ко всем элементам этого итерируемого набора или итератора, справа налево.

Примечание: не будет завершаться для бесконечных наборов.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора упорядочен или оператор ассоциативен и коммутативен.

B: тип результата бинарного оператора.
op: бинарный оператор.
returns: значение типа Option, содержащее результат reduceRight(op) , если этот итерируемый набор или итератор не пустой, None в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

def repr: Seq[A]

Коллекция типа итерируемый набор, лежащий в основе этого объекта TraversableLike. По умолчанию это сам объект TraversableLike, но это можно переопределить.

Definition Classes: TraversableLike → GenTraversableLike

def reverse: Seq[A]

Возвращает новый набор с элементами в обратном порядке.

Примечание: не будет завершаться для бесконечных наборов.

returns: Новый набор со всеми элементами этого набора в обратном порядке.

Definition Classes: SeqLike → GenSeqLike

def reverseIterator: Iterator[A]

Итератор, возвращающий элементы в обратном порядке.

Примечание: не будет завершаться для бесконечных наборов.

Примечание: xs.reverseIterator то же самое, что и xs.reverse.iterator, но может быть более эффективным.

returns: итератор, возвращающий элементы этого набора в обратном порядке

Definition Classes: SeqLike

def reverseMap[B](f: (A) ⇒ B): Seq[B]

[use case]

Создает новую коллекцию, применяя функцию ко всем элементам этого набора и собирая результаты в обратном порядке.

Примечание: не будет завершаться для бесконечных наборов.

Примечание: xs.reverseMap(f) то же самое, что и xs.reverse.map(f), но может быть более эффективным.

B: тип элементов возвращаемой коллекции.
f: функция, которую нужно применить к каждому элементу.
returns: новый набор, полученный в результате применения заданной функции f к каждому элементу этого набора и сбора результатов в обратном порядке.

Definition Classes: SeqLike → GenSeqLike

def reversed: List[A]

Атрибуты: protected[this]
Definition Classes: TraversableOnce

def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean

Составляет эту частичную функцию с функцией действия, которая применяется к результатам этой частичной функции. Функция действия вызывается только для побочных эффектов; её результат игнорируется.

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

за исключением того, что runWith реализовано через applyOrElse и, следовательно, потенциально более эффективно. Использование runWith избегает двойной оценки сопоставителей шаблонов и условий для литералов частичных функций.

action: функция действия
returns: функция, которая сопоставляет аргументы x со значением isDefinedAt(x). Результирующая функция запускает action(this(x)) там, где this определена.

Definition Classes: PartialFunction
Since: 2.10
См. также: applyOrElse.

def sameElements(that: GenIterable[A]): Boolean

[use case]

Проверяет, содержит ли другой итерируемый набор те же элементы в том же порядке, что и этот набор.

Примечание: не будет завершаться для бесконечных наборов.

that: коллекция для сравнения.
returns: true, если обе коллекции содержат одинаковые элементы в том же порядке, false в противном случае.

Definition Classes: IterableLike → GenIterableLike

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Seq[A], B, That]): That

Вычисляет префиксный скан элементов коллекции.

Примечание: нейтральный элемент z может применяться более одного раза.

B: тип элементов результирующей коллекции
That: тип результирующей коллекции
z: нейтральный элемент для оператора op
op: ассоциативный оператор для сканирования
cbf: фабрика объединителей, которая предоставляет объединитель
returns: новая коллекция, содержащая префиксный скан элементов в этой коллекции

Определяющие классы: TraversableLike → GenTraversableLike

def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[Seq[A], B, That]): That

Создает коллекцию, содержащую кумулятивные результаты применения оператора слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если только базовый тип коллекции не упорядочен.

B: тип элементов в результирующей коллекции
That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: неявное значение класса CanBuildFrom которое определяет результирующий класс That из текущего типа представления Repr и нового типа элемента B.
returns: коллекция с промежуточными результатами

Определяющие классы: TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[Seq[A], B, That]): That

Создает коллекцию, содержащую кумулятивные результаты применения оператора справа налево. Голова коллекции — последний кумулятивный результат.

Примечание: не завершится для коллекций бесконечного размера.

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

B: тип элементов в результирующей коллекции
That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: неявное значение класса CanBuildFrom которое определяет результирующий класс That из текущего типа представления Repr и нового типа элемента B.
returns: коллекция с промежуточными результатами

Определяющие классы: TraversableLike → GenTraversableLike
Аннотации: @migration
Миграция: (Изменено в версии 2.9.0) Поведение scanRight изменилось. Предыдущее поведение может быть воспроизведено с помощью scanRight.reverse.

def segmentLength(p: (A) ⇒ Boolean, from: Int): Int

Вычисляет длину самого длинного сегмента, элементы которого удовлетворяют некоторому предикату.

Примечание: может не завершиться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
from: индекс, с которого начинается поиск.
returns: длина самого длинного сегмента этой последовательности, начиная с индекса from, такого что каждый элемент сегмента удовлетворяет предикату p.

Определяющие классы: SeqLike → GenSeqLike

def seq: Seq[A]

Вариант этой коллекции со всеми операциями, реализованными последовательно (т.е. однопоточно).

Этот метод возвращает ссылку на эту коллекцию. В параллельных коллекциях он переопределен для возврата последовательной реализации этой коллекции. В обоих случаях он имеет сложность O(1).

returns: последовательный вид коллекции.

Определяющие классы: Seq → GenSeq → GenSeqLike → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce

def size: Int

Размер этой последовательности, эквивалентный length.

Примечание: не завершится для коллекций бесконечного размера.

возвращает: количество элементов в этой последовательности.

Классы определений: SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

def sizeHintIfCheap: Int

Размер этого набора или итератора, если его можно вычислить недорого

возвращает: количество элементов в этом наборе или итераторе, или -1, если размер нельзя определить недорого

Атрибуты: protected[collection]
Классы определений: GenTraversableOnce

def slice(from: Int, until: Int): Seq[A]

Выбирает интервал элементов. Возвращаемая коллекция состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

возвращает: итерабельная коллекция, содержащая элементы, большие или равные индексу from, и простирающиеся до (но не включая) индекса until этой итерабельной коллекции.

Классы определений: IterableLike → TraversableLike → GenTraversableLike

def sliding(size: Int, step: Int): Iterator[Seq[A]]

Группирует элементы в блоки фиксированного размера, пропуская «скользящее окно» над ними (в отличие от разбиения их, как это делается в grouped).

size: количество элементов в группе
step: расстояние между первыми элементами последовательных групп
возвращает: Итератор, генерирующий итерабельные коллекции размера size, за исключением последнего элемента (который может быть единственным элементом), который будет усечен, если оставшихся элементов меньше, чем size.

Классы определений: IterableLike
См. также: scala.collection.Iterator, метод sliding

def sliding(size: Int): Iterator[Seq[A]]

Группирует элементы в блоки фиксированного размера, пропуская «скользящее окно» над ними (в отличие от разбиения их, как это делается в grouped). Шаг «скользящего окна» установлен в единицу.

size: количество элементов в группе
возвращает: Итератор, генерирующий итерабельные коллекции размера size, за исключением последнего элемента (который может быть единственным элементом), который будет усечен, если оставшихся элементов меньше, чем size.

Классы определений: IterableLike
См. также: scala.collection.Iterator, метод sliding

def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): Seq[A]

Сортирует эту Seq в соответствии с упорядочиванием, которое получается из преобразования неявно заданного упорядочивания с помощью функции преобразования.

B: целевой тип преобразования f, и тип, где определено упорядочение ord.
f: функция преобразования, отображающая элементы в какую-то другую область B.
ord: упорядочение, предполагаемое в области B.
возвращает: последовательность, состоящая из элементов этой последовательности, отсортированных в соответствии с порядком, где x < y если ord.lt(f(x), f(y)).

Классы определений: SeqLike
См. также: scala.math.Ordering Примечание: не завершится для коллекций бесконечного размера.

def sortWith(lt: (A, A) ⇒ Boolean): Seq[A]

Сортирует эту последовательность в соответствии с функцией сравнения.

Примечание: не завершится для коллекций бесконечного размера.

Сортировка устойчива. То есть, элементы, которые равны (как определяется lt) появляются в отсортированной последовательности в том же порядке, что и в исходной.

lt: функция сравнения, проверяющая, предшествует ли ее первый аргумент второму аргументу в требуемом порядке.
возвращает: последовательность, состоящая из элементов этой последовательности, отсортированных в соответствии с функцией сравнения lt.

Классы определений: SeqLike

def sorted[B >: A](implicit ord: math.Ordering[B]): Seq[A]

Сортирует эту последовательность в соответствии с упорядочиванием.

Сортировка устойчивая. То есть, элементы, которые равны (как определяется lt) появляются в отсортированной последовательности в том же порядке, что и в исходной.

ord: упорядочение, используемое для сравнения элементов.
возвращает: последовательность, состоящая из элементов этой последовательности, отсортированных в соответствии с упорядочиванием ord.

Классы определений: SeqLike
См. также: scala.math.Ordering

def span(p: (A) ⇒ Boolean): (Seq[A], Seq[A])

Разделяет эту коллекцию итераций на пару префикс/суффикс в соответствии с предикатом.

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

возвращает: пару, содержащую самый длинный префикс этой итерируемой коллекции, элементы которой удовлетворяют условию p, и остальную часть этой итерируемой коллекции.

Definition Classes: TraversableLike → GenTraversableLike

def splitAt(n: Int): (Seq[A], Seq[A])

Разделяет эту итерируемую коллекцию на две части в заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

n: позиция разделения.
возвращает: пару итерируемых коллекций, состоящих из первых n элементов этой итерируемой коллекции и остальных элементов.

Definition Classes: TraversableLike → GenTraversableLike

def startsWith[B](that: GenSeq[B], offset: Int): Boolean

Проверяет, содержит ли эта последовательность заданную последовательность в заданном индексе.

Примечание: Если как получаемый объект this, так и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

that: тестируемая последовательность
offset: индекс, где ищется последовательность.
возвращает: true, если последовательность that содержится в этой последовательности по индексу offset, в противном случае false.

Definition Classes: SeqLike → GenSeqLike

def startsWith[B](that: GenSeq[B]): Boolean

Проверяет, начинается ли эта общая последовательность с заданной последовательности.

that: тестируемая последовательность
возвращает: true, если эта коллекция имеет that в качестве префикса, false в противном случае.

Definition Classes: GenSeqLike

def stringPrefix: String

Определяет префикс представления этого объекта toString.

возвращает: строковое представление, которое начинается с результата toString для этой итерируемой коллекции. По умолчанию строковый префикс - это простое имя класса коллекции - итерируемой коллекции.

Definition Classes: TraversableLike → GenTraversableLike

def sum: A

[use case]

Суммирует элементы этой коллекции.

возвращает: сумму всех элементов в этой последовательности чисел типа Int. Вместо Int, может быть использован любой другой тип T с неявной реализацией Numeric[T] в качестве типа элемента последовательности и типа результата sum. Примеры таких типов: Long, Float, Double, BigInt.

Definition Classes: TraversableOnce → GenTraversableOnce

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def tail: Seq[A]

Выбирает все элементы, кроме первого.

возвращает: итерируемая коллекция, содержащая все элементы этой итерируемой коллекции, кроме первого.

Definition Classes: TraversableLike → GenTraversableLike
Исключения: java.lang.UnsupportedOperationException, если итерируемая коллекция пустая.

def tails: Iterator[Seq[A]]

Итерирует по хвостам этой итерируемой коллекции. Первое значение будет этой итерируемой коллекцией, а последнее - пустой итерируемой коллекцией, а промежуточные значения - результатами последовательного применения tail.

возвращает: итератор по всем хвостам этой итерируемой коллекции

Definition Classes: TraversableLike

def take(n: Int): Seq[A]

Выбирает первые n элементов.

Примечание: могут быть получены разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

n: число элементов, которые нужно взять из этой итерируемой коллекции.
возвращает: итерируемая коллекция, содержащая только первые n элементов этой итерируемой коллекции, или же вся итерируемая коллекция, если в ней меньше n элементов. Если n отрицательно, возвращает пустую итерируемую коллекцию.

Определяющие классы: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): Seq[A]

Выбирает последние n элементов.

n: количество элементов для взятия
возвращает: итерируемая коллекция, содержащая только последние n элементов этой итерируемой коллекции, или же вся итерируемая коллекция, если в ней меньше n элементов.

Определяющие классы: IterableLike

def takeWhile(p: (A) ⇒ Boolean): Seq[A]

Взять самую длинную префиксную последовательность элементов, удовлетворяющих предикату.

возвращает: самую длинную префиксную последовательность этой итерируемой коллекции, элементы которой удовлетворяют предикату p.

Определяющие классы: IterableLike → TraversableLike → GenTraversableLike

def thisCollection: Seq[A]

Базовая коллекция, рассматриваемая как экземпляр Seq. По умолчанию это сама текущая коллекция, но это можно переопределить.

Атрибуты: protected[this]
Определяющие классы: SeqLike → IterableLike → TraversableLike

def to[Col[_]]: Col[A]

[служебный случай]

Преобразует эту последовательность в другую, копируя все элементы.

Примечание: не будет завершаться для бесконечно больших коллекций.

Col: Тип коллекции для построения.
возвращает: новая коллекция, содержащая все элементы этой последовательности.

Определяющие классы: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[служебный случай]

Преобразует эту последовательность в массив.

Примечание: не будет завершаться для бесконечно больших коллекций.

возвращает: массив, содержащий все элементы этой последовательности. Для типа элементов этой последовательности должен быть доступен ClassTag.

Определяющие классы: TraversableOnce → GenTraversableOnce

def toBuffer[B >: A]: Buffer[B]

Использует содержимое этого перечисляемого объекта или итератора для создания нового изменяемого буфера.

Примечание: не будет завершаться для бесконечно больших коллекций.

возвращает: буфер, содержащий все элементы этого перечисляемого объекта или итератора.

Определяющие классы: TraversableOnce → GenTraversableOnce

def toCollection(repr: Seq[A]): Seq[A]

Преобразование из коллекций типа Repr в объекты Seq. По умолчанию это реализуется просто как приведение типа, но это можно переопределить.

Атрибуты: protected[this]
Определяющие классы: SeqLike → IterableLike → TraversableLike

def toIndexedSeq: immutable.IndexedSeq[A]

Преобразование этого перечисляемого объекта или итератора в индексированную последовательность.

Примечание: не будет завершаться для бесконечно больших коллекций.

возвращает: индексированная последовательность, содержащая все элементы этого перечисляемого объекта или итератора.

Определяющие классы: TraversableOnce → GenTraversableOnce

def toIterable: Iterable[A]

Возвращает эту итерируемую коллекцию как итерируемую коллекцию.

Новая коллекция не будет построена; ленивые коллекции останутся ленивыми.

Примечание: не будет завершаться для бесконечно больших коллекций.

возвращает: итерируемый объект, содержащий все элементы этой итерируемой коллекции.

Определяющие классы: IterableLike → TraversableOnce → GenTraversableOnce

def toIterator: Iterator[A]

Возвращает итератор по элементам в этом итерируемом наборе. Возвращает тот же результат, что и iterator.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: Итератор, содержащий все элементы этого итерируемого набора.

Классы определения: IterableLike → TraversableLike → GenTraversableOnce
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def toList: List[A]

Преобразует это итерируемое или итератор в список.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: Список, содержащий все элементы этого итерируемого или итератора.

Классы определения: TraversableOnce → GenTraversableOnce

def toMap[T, U]: Map[T, U]

[use case]

Преобразует эту последовательность в карту. Этот метод недоступен, если элементы не являются членами Tuple2, при этом каждый ((T, U)) становится парой ключ-значение в карте. Дублирующиеся ключи будут перезаписываться последующими ключами: если это неупорядоченная коллекция, ключ в результирующей карте не определен.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: карта типа immutable.Map[T, U], содержащая все пары ключ/значение типа (T, U) этой последовательности.

Классы определения: TraversableOnce → GenTraversableOnce

def toParArray: ParArray[T]

Неявный: Этот член добавлен неявным преобразованием из Seq[A] в CollectionsHaveToParArray[Seq[A], T] с помощью метода CollectionsHaveToParArray в scala.collection.parallel. Это преобразование произойдёт только если неявное значение типа (Seq[A]) ⇒ GenTraversableOnce[T] находится в области видимости.
Классы определения: CollectionsHaveToParArray

def toSeq: Seq[A]

Преобразует эту последовательность в последовательность.

Примечание: не будет завершаться для коллекций бесконечного размера.

Новая коллекция не будет построена; в частности, ленивые последовательности останутся ленивыми.

returns: последовательность, содержащая все элементы этой последовательности.

Классы определения: SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce

def toSet[B >: A]: immutable.Set[B]

Преобразует это итерируемое или итератор в множество.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: множество, содержащее все элементы этого итерируемого или итератора.

Классы определения: TraversableOnce → GenTraversableOnce

def toStream: immutable.Stream[A]

Преобразует эту итерируемую коллекцию в поток.

returns: поток, содержащий все элементы этой итерируемой коллекции.

Классы определения: IterableLike → TraversableLike → GenTraversableOnce

def toString(): String

Преобразует эту последовательность в строку.

returns: строковое представление этой коллекции. По умолчанию эта строка состоит из stringPrefix этой последовательности, за которой следуют все элементы, разделенные запятыми и заключённые в скобки.

Классы определения: SeqLike → TraversableLike → Any

def toTraversable: Traversable[A]

Преобразует эту итерируемую коллекцию в неопределённое итерируемое. Вернёт ту же самую коллекцию, если этот экземпляр уже является итерируемым.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: Итерируемое, содержащее все элементы этой итерируемой коллекции.

Классы определения: TraversableLike → TraversableOnce → GenTraversableOnce
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def toVector: Vector[A]

Преобразует этот обходной элемент или итератор в вектор.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: вектор, содержащий все элементы этого обходного элемента или итератора.

Определяющие классы: TraversableOnce → GenTraversableOnce

def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Seq[Seq[B]]

Транспонирует эту коллекцию коллекций обхода в коллекцию коллекций.

Тип результирующей коллекции будет определяться статическим типом коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

B: тип элементов каждой коллекции обхода.
asTraversable: явное преобразование, которое утверждает, что тип элемента этой коллекции является Traversable.
возвращает: двухмерная коллекция коллекций, у которой n-я строка — это n-й столбец этой коллекции.

Определяющие классы: GenericTraversableTemplate
Аннотации: @migration
Миграция: (Изменено в версии 2.9.0) transpose выбрасывает IllegalArgumentException , если размеры коллекций не одинаковы.
Исключения: IllegalArgumentException, если все коллекции в этой коллекции не имеют одинаковый размер.

def union(that: Seq[A]): Seq[A]

[пример использования]

Создает новую последовательность, которая содержит все элементы этой последовательности и все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это состоит в том, что xs union ys вычисляет сохраняющую порядок множественное объединение xs и ys. union является поэтому аналогом diff и intersect, которые также работают с множествами.

Примечание: не будет завершаться для коллекций бесконечного размера.

that: последовательность для добавления.
возвращает: новую последовательность, которая содержит все элементы этой последовательности, за которыми следуют все элементы that.

Определяющие классы: SeqLike → GenSeqLike

def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Seq[A1], Seq[A2])

Преобразует эту коллекцию пар в две коллекции первой и второй половины каждой пары.

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

A1: тип первой половины пар элементов
A2: тип второй половины пар элементов
asPair: явное преобразование, которое утверждает, что тип элемента этой коллекции является парой.
возвращает: пара коллекций, содержащая первую и вторую половину каждой пары элементов этой коллекции.

Определяющие классы: GenericTraversableTemplate

def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Seq[A1], Seq[A2], Seq[A3])

Преобразует эту коллекцию троек в три коллекции первого, второго и третьего элемента каждой тройки.

val xs = Traversable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three),
//        Traversable(1, 2, 3))

A1: тип первого члена троек элементов
A2: тип второго члена троек элементов
A3: тип третьего члена троек элементов
asTriple: явное преобразование, которое утверждает, что тип элемента этой коллекции — тройка.
возвращает: тройку коллекций, содержащую первый, второй и, соответственно, третий член каждой тройки элементов этой коллекции.

Определяющие классы: GenericTraversableTemplate

def updated(index: Int, elem: A): Seq[A]

[пример использования]

Копия этой последовательности с одним замененным элементом.

index: позиция замены
elem: заменяемый элемент
возвращает: копия этой последовательности с элементом в позиции index замененным на elem.

Определяющие классы: SeqLike → GenSeqLike

def view(from: Int, until: Int): SeqView[A, Seq[A]]

Создаёт нестрогий вид среза этой последовательности.

Примечание: разница между view и slice заключается в том, что view создаёт представление текущей последовательности, а slice создаёт новую последовательность.

Примечание: view(from, to) эквивалентно view.slice(from, to)

from: индекс первого элемента представления
until: индекс элемента, следующего за представлением
returns: нестрогий вид среза этой последовательности, начинающийся с индекса from и простирающийся до (но не включая) индекс until.

Definition Classes: SeqLike → IterableLike → TraversableLike

def view: SeqView[A, Seq[A]]

Создаёт нестрогий вид этой последовательности.

returns: нестрогий вид этой последовательности.

Definition Classes: SeqLike → IterableLike → TraversableLike

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, Seq[A]]

Создаёт нестрогий фильтр этого коллектора.

Примечание: разница между c filter p и c withFilter p в том, что первый создаёт новый коллектор, а второй только ограничивает область последующих map, flatMap, foreach, и withFilter операций.

Примечание: может возвращать разные результаты при разных запусках, если тип базового коллектора не упорядочен.

p: предикат для проверки элементов.
returns: объект класса WithFilter, который поддерживает map, flatMap, foreach, и withFilter операции. Все эти операции применяются к тем элементам этого коллектора, которые удовлетворяют предикату p.

Definition Classes: TraversableLike → FilterMonadic

def zip[B](that: GenIterable[B]): Seq[(A, B)]

[use case]

Возвращает последовательность, образованную из этой последовательности и другого итерируемого набора, объединяя соответствующие элементы в пары. Если один из двух наборов длиннее другого, его оставшиеся элементы игнорируются.

B: тип второй половины возвращаемых пар
that: Итерируемый набор, предоставляющий вторую половину каждой пары результатов
returns: новая последовательность, содержащая пары, состоящие из соответствующих элементов этой последовательности и that. Длина возвращаемого набора равна минимальному значению длин этой последовательности и that.

Definition Classes: IterableLike → GenIterableLike

def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): Seq[(A, B)]

[use case]

Возвращает последовательность, образованную из этой последовательности и другого итерируемого набора, объединяя соответствующие элементы в пары. Если один из двух наборов короче другого, для заполнения более короткого набора используются значения-заполнители до длины более длинного.

B: тип второй половины возвращаемых пар
that: Итерируемый набор, предоставляющий вторую половину каждой пары результатов
thisElem: элемент, используемый для заполнения результата, если эта последовательность короче that.
thatElem: элемент, используемый для заполнения результата, если that короче этой последовательности.
returns: новая последовательность, содержащая пары, образованные из соответствующих элементов этой последовательности и that. Длина возвращаемого набора равна максимальному значению длин этой последовательности и that. Если эта последовательность короче that, значения thisElem используются для заполнения результата. Если that короче этой последовательности, значения thatElem используются для заполнения результата.

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex: Seq[(A, Int)]

[пример использования]

Объединяет эту последовательность со своими индексами.

возвращает: Новая последовательность, содержащая пары, состоящие из всех элементов этой последовательности, сопоставленных с их индексом. Индексы начинаются с 0.

Классы-определения: IterableLike → GenIterableLike

def →[B](y: B): (Seq[A], B)

Неявный: Этот член добавлен неявным преобразованием из Seq[A] в ArrowAssoc[Seq[A]] с помощью метода ArrowAssoc в scala.Predef.
Классы-определения: ArrowAssoc

Затенённые неявные члены значения

def filter(p: (A) ⇒ Boolean): TraversableOnce[A]

Неявный

Этот член добавлен неявным преобразованием из Seq[A] в MonadOps[A] с помощью метода MonadOps в scala.collection.TraversableOnce.

Затенение

Этот неявный наследуемый член затенён одним или несколькими членами в этом классе.
Для доступа к этому члену можно использовать приведение типа:

(seq: MonadOps[A]).filter(p)

Классы-определения

MonadOps

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]

Неявный

Этот член добавлен неявным преобразованием из Seq[A] в MonadOps[A] с помощью метода MonadOps в scala.collection.TraversableOnce.

Затенение

(seq: MonadOps[A]).flatMap(f)

Классы-определения

MonadOps

def map[B](f: (A) ⇒ B): TraversableOnce[B]

Неявный

Этот член добавлен неявным преобразованием из Seq[A] в MonadOps[A] с помощью метода MonadOps в scala.collection.TraversableOnce.

Затенение

(seq: MonadOps[A]).map(f)

Классы-определения

MonadOps

def withFilter(p: (A) ⇒ Boolean): Iterator[A]

Неявный

Этот член добавлен неявным преобразованием из Seq[A] в MonadOps[A] с помощью метода MonadOps в scala.collection.TraversableOnce.

Затенение

(seq: MonadOps[A]).withFilter(p)

Классы-определения

MonadOps

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/Seq.html