Трейт scala.collection.IndexedSeqLike

трейт IndexedSeqLike[+A, +Repr] extends SeqLike[A, Repr]

Шаблонный трейт для индексированных последовательностей типа IndexedSeq[A].

Индексированные последовательности поддерживают доступ к элементам и вычисление длины за постоянное или близкое к постоянному время. Они определяются в терминах абстрактных методов apply для индексирования и length.

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

Этот трейт просто реализует iterator в терминах apply и length. Однако, см. IndexedSeqOptimized для реализации трейта, который переопределяет операции, чтобы они выполнялись быстрее при условии быстрого произвольного доступа с apply.

Self Type: IndexedSeqLike[A, Repr]
Source: IndexedSeqLike.scala

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

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

Типы-члены

класс Elements extends AbstractIterator[A] with BufferedIterator[A] with Serializable

Класс итератора, возвращаемого методом iterator. несколько take, drop, и slice операций над этим итератором объединяются для повышения эффективности.

Атрибуты: protected
Аннотации: @SerialVersionUID()

тип Self = Repr

Тип, реализующий этот обход

Атрибуты: 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 getClass(): Class[_]

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

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

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

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

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

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

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

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

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

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

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

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

абстрактный def seq: IndexedSeq[A]

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

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

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

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

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

final def !=(arg0: Any): Boolean

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

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

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

final def ##(): Int

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

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

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

def +(other: String): String

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

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

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

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

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

def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, 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.
возвращает: новая коллекция типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

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

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

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

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

Пример:

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.

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

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

[случай использования]

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

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

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

Пример:

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): (IndexedSeqLike[A, Repr], B)

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

[случай использования]

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

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

Пример:

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 в противном случае.

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

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

final def asInstanceOf[T0]: T0

Преобразует текущий объект в тип T0.

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

returns: текущий объект.

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

def canEqual(that: Any): Boolean

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

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

Definition Classes: IterableLike → Equals

def collect[B](pf: PartialFunction[A, B]): IndexedSeq[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[Repr]

Итерация по комбинациям. _Комбинация_ длины 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: Seq[A]): IndexedSeq[A]

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def distinct: Repr

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

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

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

Definition Classes: SeqLike → GenSeqLike

def drop(n: Int): Repr

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def dropRight(n: Int): Repr

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

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

Definition Classes: IterableLike

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

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

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

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

def ensuring(cond: (IndexedSeqLike[A, Repr]) ⇒ Boolean): IndexedSeqLike[A, Repr]

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

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

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

def ensuring(cond: Boolean): IndexedSeqLike[A, Repr]

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

def equals(that: Any): Boolean

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

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

Definition Classes: GenSeqLike → Equals → Any

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

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def filter(p: (A) ⇒ Boolean): Repr

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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]): IndexedSeq[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: нейтральный элемент для операции fold; может быть добавлен к результату любое количество раз, и не должен менять результат (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения).
op: бинарный оператор, который должен быть ассоциативным.
returns: результат применения оператора fold 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).

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

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

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

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

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[Repr]

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

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

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

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

Definition Classes: IndexedSeqLike → GenSeqLike → Any

def head: A

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

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike
Исключения: 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: Repr

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

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

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

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

def inits: Iterator[Repr]

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

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

Definition Classes: TraversableLike

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

[случай использования]

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

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 iterator: Iterator[A]

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

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

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

def last: A

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

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

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

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

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

[случай использования]

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

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

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

def lastIndexOf(elem: A): Int

[случай использования]

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

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

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

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

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

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

Определяющие классы: 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): IndexedSeq[B]

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

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

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

def nonEmpty: Boolean

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def padTo(len: Int, elem: A): IndexedSeq[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): (Repr, Repr)

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def permutations: Iterator[Repr]

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: GenSeqLike

def product: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

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

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

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

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

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

B

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

op

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

returns

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

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

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

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

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def repr: Repr

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: Repr

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reverseIterator: Iterator[A]

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reversed: List[A]

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

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

[use case]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def size: Int

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

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

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

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

def sizeHintIfCheap: Int

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

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

Атрибуты: protected[collection]
Определяющие классы: IndexedSeqLike → GenTraversableOnce

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

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

from <= indexOf(x) < until

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

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

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

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

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

Определяющие классы: IterableLike
См. также: scala.collection.Iterator, метод sliding

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

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

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

Определяющие классы: IterableLike
См. также: scala.collection.Iterator, метод sliding

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

Сортирует эту 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): Repr

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

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

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

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

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

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

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

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

Определяющие классы: SeqLike
См. также: scala.math.Ordering

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

Разделяет эту итерационную коллекцию на две части в заданной позиции. Примечание: 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

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

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

def tail: Repr

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

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

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

def tails: Iterator[Repr]

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

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

Definition Classes: TraversableLike

def take(n: Int): Repr

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): Repr

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

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

Definition Classes: IterableLike

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

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def thisCollection: IndexedSeq[A]

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

Attributes: protected[this]
Definition Classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike

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

[use case]

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

Definition Classes: IndexedSeqLike → TraversableOnce → GenTraversableOnce

def toCollection(repr: Repr): IndexedSeq[A]

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

Attributes: protected[this]
Definition Classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toIterable: Iterable[A]

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

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

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

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

Definition Classes: 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]: Map[T, U]

[use case]

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

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

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

def toParArray: ParArray[T]

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

def toSeq: 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: Traversable[A]

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

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

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

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

def toVector: Vector[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

Примечание: разница между 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, Repr]

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

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

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

Примечание: различие между 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]): IndexedSeq[(A, B)]

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

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

[use case]

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

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

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

def zipWithIndex: IndexedSeq[(A, Int)]

[use case]

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

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

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

def →[B](y: B): (IndexedSeqLike[A, Repr], B)

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

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

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

Неявный

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

Затенение

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

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

(indexedSeqLike: 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/IndexedSeqLike.html