Трейт scala.collection.mutable.SeqLike

трейт SeqLike[A, +This <: SeqLike[A, This] with Seq[A]] extends collection.SeqLike[A, This] with Cloneable[This] with Parallelizable[A, ParSeq[A]]

Шаблонный трейт для изменяемых последовательностей типа mutable.Seq[A].

A: тип элементов множества
This: тип самого множества.

Self Type: SeqLike[A, This]
Source: SeqLike.scala

Линейные супертипы

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

Члены типов

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

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

Definition Classes: TraversableLike

тип Self = This

Тип, реализующий эту итерацию

Attributes: protected[this]
Definition Classes: 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: Индекс для выбора.
returns: элемент этой последовательности по индексу idx, где 0 обозначает первый элемент.

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

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

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

returns: новый итератор

Definition Classes: IterableLike → GenIterableLike

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

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

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

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

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

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

абстрактный def newBuilder: Builder[A, This]

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

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

абстрактный def seq: collection.Seq[A]

Definition Classes: GenSeqLike → Parallelizable → GenTraversableOnce

абстрактный def update(idx: Int, elem: A): Unit

Заменяет элемент по заданному индексу новым значением.

idx: индекс элемента для замены.
elem: новое значение.

Исключения: IndexOutOfBoundsException, если индекс некорректен.

Члены конкретных значений

final def !=(arg0: Any): Boolean

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

returns: true если !(this == that), в противном случае false.

Definition Classes: AnyRef → Any

final def ##(): Int

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

returns: значение хеша, согласованное с ==

Definition Classes: AnyRef → Any

def +(other: String): String

Implicit: Этот член добавлен с помощью неявного преобразования из SeqLike[A, This] в any2stringadd[SeqLike[A, This]] с помощью метода any2stringadd в scala.Predef.
Definition Classes: any2stringadd

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

Пример:

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.
returns: новая коллекция типа 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: объединяемая коллекция.
returns: новая последовательность, которая содержит все элементы этой последовательности, за которыми следуют все элементы that.

Definition Classes: TraversableLike

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

[use case]

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

Обратите внимание, что операторы с окончанием двоеточием являются правоассоциативными (см. пример). Мнемоника для +: против :+ такова: двоеточие ставится со стороны коллекции.

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

Пример:

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: элемент, добавляемый в начало
возвращает: новая последовательность, состоящая из elem и всех элементов этой последовательности.

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

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

Неявный: Этот член добавляется неявным преобразованием из SeqLike[A, This] в ArrowAssoc[SeqLike[A, This]], выполненное методом ArrowAssoc в scala.Predef.
Классы-определения: ArrowAssoc
Аннотации: @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

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

возвращает

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

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

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

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

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

[use case]

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

Мнемоника для +: против :+ такова: двоеточие ставится со стороны коллекции.

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

Пример:

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: элемент, добавляемый в конец
возвращает: новая последовательность, состоящая из всех элементов этой последовательности, за которыми следует elem.

Классы-определения: 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

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

возвращает

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

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

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

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

final def ==(arg0: Any): Boolean

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

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

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

def addString(b: scala.StringBuilder): scala.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: строковый буфер, в который добавляются элементы.
возвращает: строковый буфер b, в который были добавлены элементы.

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

def addString(b: scala.StringBuilder, sep: String): scala.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: scala.StringBuilder, start: String, sep: String, end: String): scala.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

final def asInstanceOf[T0]: T0

Преобразует получаемый объект в тип T0.

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

returns: получаемый объект.

Definition Classes: Any
Исключения: ClassCastException, если получаемый объект не является экземпляром стирания типа T0.

def canEqual(that: Any): Boolean

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

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

Definition Classes: IterableLike → Equals

def clone(): This

Создает копию объекта-приемника.

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

returns: копия объекта-приемника.

Definition Classes: Cloneable → AnyRef
Примечание: не указано SLS как член AnyRef

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

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

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

Definition Classes: TraversableOnce

def combinations(n: Int): Iterator[This]

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

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

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

Definition Classes: SeqLike

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: collection.Seq[A]): Seq[A]

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def distinct: This

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

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

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

Definition Classes: SeqLike → GenSeqLike

def drop(n: Int): This

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

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def dropRight(n: Int): This

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

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

Definition Classes: IterableLike

def dropWhile(p: (A) ⇒ Boolean): This

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

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: (SeqLike[A, This]) ⇒ Boolean, msg: ⇒ Any): SeqLike[A, This]

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

def ensuring(cond: (SeqLike[A, This]) ⇒ Boolean): SeqLike[A, This]

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

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

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

def ensuring(cond: Boolean): SeqLike[A, This]

Неявный: Этот член добавлен неявным преобразованием из SeqLike[A, This] в Ensuring[SeqLike[A, This]] с помощью метода 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): This

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

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

Definition Classes: TraversableLike → GenTraversableLike

def filterNot(p: (A) ⇒ Boolean): This

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

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

Definition Classes: TraversableLike → GenTraversableLike

def finalize(): Unit

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

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

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )
Примечание: не указано SLS в качестве члена AnyRef

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

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

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

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

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

Definition Classes: 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 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 (@см java.lang.String.format).

Неявный: Этот член добавляется с помощью неявного преобразования из SeqLike[A, This] в StringFormat[SeqLike[A, This]] с помощью метода StringFormat в scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

final def getClass(): Class[_]

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

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

Definition Classes: AnyRef → Any
Annotations: @native()

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

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

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

K

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

f

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

returns

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def grouped(size: Int): Iterator[This]

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

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

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

def hasDefiniteSize: Boolean

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

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

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

Definition Classes: GenSeqLike → Any

def head: A

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

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

returns: первый элемент этой итерируемой коллекции.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException, если итерируемая коллекция пуста.

def headOption: Option[A]

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

[use case]

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

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

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

Definition Classes: GenSeqLike

def indexOf(elem: A): Int

[use case]

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

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

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

Definition Classes: GenSeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

Definition Classes: GenSeqLike

def indices: immutable.Range

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

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

Definition Classes: SeqLike

def init: This

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

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

Definition Classes: TraversableLike → GenTraversableLike
Exceptions thrown: UnsupportedOperationException, если итерируемая коллекция пуста.

def inits: Iterator[This]

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

returns: итератор по всем начальным фрагментам (inits) этой итерируемой коллекции

Definition Classes: TraversableLike

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

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

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

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

Definition Classes: GenSeqLike

def isEmpty: Boolean

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes: Any

final def isTraversableAgain: Boolean

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

returns: true

Definition Classes: TraversableLike → GenTraversableLike → GenTraversableOnce

def last: A

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

returns: Последний элемент этой итерируемой коллекции.

Definition Classes: TraversableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException , если итерируемая коллекция пуста.

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

[use case]

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

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

Definition Classes: GenSeqLike

def lastIndexOf(elem: A): Int

[use case]

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

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

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

Definition Classes: 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: последний элемент этой коллекции, если она непуста, 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 map[B](f: (A) ⇒ B): Seq[B]

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

Находит максимальный элемент.

returns: наибольший элемент этого набора.

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если этот набор пуст.

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

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если этот набор пуст.

def min: A

[use case]

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

returns: наименьший элемент этого набора

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если этот набор пуст.

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

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если этот набор пуст.

def mkString: String

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

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

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

Definition Classes: AnyRef

def nonEmpty: Boolean

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

returns: true если перечислимый объект или итератор содержит хотя бы один элемент, 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()
Примечание: не указано SLS в качестве члена AnyRef

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def par: ParSeq[A]

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

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

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

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

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

Definition Classes: Parallelizable

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

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

возвращает: комбинер для параллельного набора типа ParRepr

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

def partition(p: (A) ⇒ Boolean): (This, This)

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def permutations: Iterator[This]

Итерирует по различным перестановкам.

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: 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: Бинарный оператор, который должен быть ассоциативным.
возвращает: Результат применения оператора reduce 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: бинарный оператор.
возвращает: значение опции, содержащей результат reduceLeft(op) , если этот обход или итератор не пустой, None в противном случае.

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

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

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

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

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

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

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

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

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

B

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

op

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

возвращает

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

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

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

Определяющие классы: 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: This

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: This

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

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

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]

Attributes: protected[this]
Definition Classes: TraversableOnce

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[This, B, That]): That

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[This, 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: коллекция с промежуточными результатами

Definition Classes: TraversableLike → GenTraversableLike
Annotations: @migration
Migration: (Изменено в версии 2.9.0) Поведение scanRight изменилось. Предыдущее поведение можно воспроизвести с помощью scanRight.reverse.

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

def size: Int

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

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

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

Definition Classes: SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

def sizeHintIfCheap: Int

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

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

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(from: Int, until: Int): This

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

from <= indexOf(x) < until

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

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

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

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

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод sliding

def sliding(size: Int): Iterator[This]

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

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

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод sliding

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

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

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

Definition Classes: SeqLike
See also: scala.math.Ordering Примечание: не завершится для коллекций бесконечного размера.

def sortWith(lt: (A, A) ⇒ Boolean): This

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

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

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

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

Definition Classes: SeqLike

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

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

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

Definition Classes: SeqLike
See also: scala.math.Ordering

def span(p: (A) ⇒ Boolean): (This, This)

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def splitAt(n: Int): (This, This)

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: GenSeqLike

def stringPrefix: String

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

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

Definition Classes: TraversableLike → GenTraversableLike

def sum: A

[use case]

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

returns: сумма всех элементов в этой последовательности чисел типа 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: This

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

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

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

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

def tails: Iterator[This]

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

returns: итератор по всем хвостам этой перечислимой коллекции

Definition Classes: TraversableLike

def take(n: Int): This

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): This

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

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

Definition Classes: IterableLike

def takeWhile(p: (A) ⇒ Boolean): This

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def thisCollection: collection.Seq[A]

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

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

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

[use case]

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

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

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

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

def toArray: Array[A]

[use case]

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

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

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

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

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

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

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

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

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

def toCollection(repr: This): collection.Seq[A]

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

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

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

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

def toIterable: collection.Iterable[A]

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

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

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

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

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

def toIterator: Iterator[A]

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

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

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

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

def toList: List[A]

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

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

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

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

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

[use case]

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

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

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

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

def toParArray: ParArray[T]

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

def toSeq: collection.Seq[A]

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

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

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

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

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

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

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

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

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

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

def toStream: immutable.Stream[A]

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

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

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

def toString(): String

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

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

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

def toTraversable: collection.Traversable[A]

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

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

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

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

def toVector: Vector[A]

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

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

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

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

def transform(f: (A) ⇒ A): SeqLike.this.type

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

f: преобразование для применения
возвращает: сама последовательность.

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

[use case]

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

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

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

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

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

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

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

Создаёт нестрогую (lazy) визуализацию среза этой последовательности.

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

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

def view: SeqView[A, This]

Создаёт нестрогую (lazy) визуализацию этой последовательности.

returns: нестрогую (lazy) визуализацию этой последовательности.

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, This]

Создаёт нестрогую (lazy) фильтрацию этой последовательности.

Примечание: разница между 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: collection.Iterable[B], thisElem: A, thatElem: B): Seq[(A, B)]

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

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

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

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

def zipWithIndex: Seq[(A, Int)]

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

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

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

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

def →[B](y: B): (SeqLike[A, This], B)

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

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

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

Неявный

Этот член добавлен неявным преобразованием из SeqLike[A, This] в MonadOps[A], выполненным методом MonadOps в scala.collection.TraversableOnce.

Затенение

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

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

(seqLike: 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/mutable/SeqLike.html