Trait scala.collection.mutable.IndexedSeqLike

trait IndexedSeqLike[A, +Repr] extends collection.IndexedSeqLike[A, Repr]

A subtrait of scala.collection.IndexedSeq which represents sequences that can be mutated.

It declares a method update which allows updating an element at a specific index in the sequence.

This trait just implements iterator in terms of apply and length. However, see IndexedSeqOptimized for an implementation trait that overrides operations to make them run faster under the assumption of fast random access with apply.

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

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

Linear Supertypes

Known Subclasses

Члены типа

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

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

Атрибуты: protected
Определяющие классы: IndexedSeqLike
Аннотации: @SerialVersionUID()

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

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

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

тип Self = Repr

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

Атрибуты: protected[this]
Определяющие классы: 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: collection.IndexedSeq[A]

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

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

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

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

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

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

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

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

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

final def !=(arg0: Any): Boolean

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

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

Definition Classes: Any

final def ##(): Int

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

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

Definition Classes: Any

def +(other: String): String

Неявный: Этот член добавлен в результате неявного преобразования из IndexedSeqLike[A, Repr] в any2stringadd[IndexedSeqLike[A, Repr]] посредством метода any2stringadd в scala.Predef.
Definition Classes: 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.

Definition Classes: TraversableLike → GenTraversableLike

def ++:[B >: A, That](that: collection.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.

Definition Classes: TraversableLike

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

[use case]

Пример:

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

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

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

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

Definition Classes: TraversableLike

def +:(elem: A): IndexedSeq[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: элемент, добавляемый в начало
returns: новая изменяемая индексированная последовательность, состоящая из elem и всех элементов этой изменяемой индексированной последовательности.

Definition Classes: SeqLike → GenSeqLike

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

Неявный: Этот член добавлен благодаря неявной конверсии из IndexedSeqLike[A, Repr] в ArrowAssoc[IndexedSeqLike[A, Repr]], выполняемой методом ArrowAssoc в scala.Predef.
Definition Classes: 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

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

returns

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def :+(elem: A): IndexedSeq[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: элемент, добавляемый в конец
returns: новая изменяемая индексированная последовательность, содержащая все элементы этой изменяемой индексированной последовательности, за которыми следует elem.

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

Примеры:

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

final def ==(arg0: Any): Boolean

Сравнение двух объектов на равенство. Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

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

Definition Classes: 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: строковый билдер, к которому добавляются элементы.
returns: строковый билдер 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, к которому были добавлены элементы.

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

Определяющие классы: 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 преобразует каждый входной символ в Int и добавляет его к сумме (раздела). Затем combop просто нужно суммировать промежуточные результаты разделов:

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

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

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

final def asInstanceOf[T0]: T0

Привести принимаемый объект к типу T0.

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

returns: принимаемый объект.

Определяющие классы: Any
Выбрасываемые исключения: ClassCastException если принимаемый объект не является экземпляром стирания типа T0.

def canEqual(that: Any): Boolean

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implicit: This member is added by an implicit conversion from IndexedSeqLike[A, Repr] to Ensuring[IndexedSeqLike[A, Repr]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

Implicit: This member is added by an implicit conversion from IndexedSeqLike[A, Repr] to Ensuring[IndexedSeqLike[A, Repr]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

Implicit: This member is added by an implicit conversion from IndexedSeqLike[A, Repr] to Ensuring[IndexedSeqLike[A, Repr]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

Implicit: This member is added by an implicit conversion from IndexedSeqLike[A, Repr] to Ensuring[IndexedSeqLike[A, Repr]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

def equals(that: Any): Boolean

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

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

Definition Classes: GenSeqLike → Equals → Any

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

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Классы-определения: TraversableLike → GenTraversableLike → FilterMonadic

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

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

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

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

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

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

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

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

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

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

B

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

z

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

op

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

возвращает

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

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

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

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

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

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

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

def formatted(fmtstr: String): String

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

Неявный: Этот член добавлен неявным преобразованием из 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
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

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

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

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

def init: Repr

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

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

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

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

def inits: Iterator[Repr]

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

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

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

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

[use case]

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

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

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

def isDefinedAt(idx: Int): Boolean

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

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

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

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

def isEmpty: Boolean

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

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

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

final def isTraversableAgain: Boolean

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

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

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

def iterator: Iterator[A]

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

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

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

def last: A

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

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

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

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

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

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

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

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

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

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

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

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

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

def min: A

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

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

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

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

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

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

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

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

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

def mkString: String

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

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

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

def mkString(sep: String): String

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

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

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

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

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

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

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

def nonEmpty: Boolean

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

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

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

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

[use case]

A copy of this mutable indexed sequence with an element value appended until a given target length is reached.

len: the target length
elem: the padding value
returns: a new mutable indexed sequence consisting of all elements of this mutable indexed sequence followed by the minimal number of occurrences of elem so that the resulting mutable indexed sequence has a length of at least len.

Definition Classes: SeqLike → GenSeqLike

def par: ParSeq[A]

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

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

Конкретные наборы (например, par или ParArray) переопределяют это поведение по умолчанию, создавая параллельный набор, который использует те же базовые данные. Для этих наборов `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
Исключения: 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
Исключения: UnsupportedOperationException если этот перебираемый объект или итератор пуст.

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

A1: Параметр типа для бинарного оператора, супертип A.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Значение option, содержащее результат применения оператора 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: значение option, содержащее результат reduceRight(op) , если этот перебираемый объект или итератор не пуст, None в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

def repr: Repr

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

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

def reverse: Repr

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

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

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

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

def reverseIterator: Iterator[A]

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

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

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

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

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

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

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

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

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

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

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

def reversed: List[A]

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

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

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

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

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

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

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

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

from <= indexOf(x) < until

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

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

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

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

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

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

Группирует элементы в блоки фиксированного размера, пропуская «скользящее окно» по ним (в отличие от разбиения, как в 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]): Repr

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

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

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

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

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike
См. также: scala.math.Ordering

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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 к этому итерируемому набору. По умолчанию префикс строки — простое имя класса итерируемого набора.

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

def sum: A

[use case]

Суммирует элементы этого набора.

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

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

def tail: Repr

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

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

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

Классы-определения: TraversableLike → GenTraversableLike
Исключения: java.lang.UnsupportedOperationException, если итерируемый набор пустой.

def tails: Iterator[Repr]

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

returns: итератор по всем хвостам этого итерируемого набора

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

def take(n: Int): Repr

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

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

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

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

def takeRight(n: Int): Repr

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

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

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

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

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

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

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

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

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

def thisCollection: IndexedSeq[A]

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

Атрибуты: protected[this]
Классы-определения: IndexedSeqLike → IndexedSeqLike → SeqLike → IterableLike → TraversableLike

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

[use case]

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

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

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

def toArray: Array[A]

[use case]

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

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

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

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

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

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

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

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

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

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

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

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

def toIterable: collection.Iterable[A]

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

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

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

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

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

def toIterator: Iterator[A]

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

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

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

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

def toList: List[A]

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

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

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

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

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

[use case]

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

returns: карта типа 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: collection.Seq[A]

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

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

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

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

Definition Classes: SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toStream: immutable.Stream[A]

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableOnce

def toString(): String

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

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

Definition Classes: SeqLike → TraversableLike → Any

def toTraversable: collection.Traversable[A]

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce
Annotations: @deprecatedOverriding( message = ... , since = "2.11.0" )

def toVector: Vector[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def union(that: collection.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): IndexedSeqView[A, Repr]

A sub-sequence view starting at index from and extending up to (but not including) index until.

from: The index of the first element of the slice
until: The index of the element following the slice
returns: a non-strict view of a slice of this mutable indexed sequence, starting at index from and extending up to (but not including) index until.@note The difference between view and slice is that view produces a view of the current sequence, whereas slice produces a new sequence.

Definition Classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike
Note: view(from, to) is equivalent to view.slice(from, to)

def view: IndexedSeqView[A, Repr]

Creates a view of this iterable @see Iterable.View

returns: a non-strict view of this mutable indexed sequence.

Definition Classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike

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

Creates a non-strict filter of this traversable collection.

Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations.

Note: might return different results for different runs, unless the underlying collection type is ordered.

p: the predicate used to test elements.
returns: an object of class WithFilter, which supports map, flatMap, foreach, and withFilter operations. All these operations apply to those elements of this traversable collection which satisfy the predicate p.

Definition Classes: TraversableLike → FilterMonadic

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

[use case]

Returns a mutable indexed sequence formed from this mutable indexed sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

B: the type of the second half of the returned pairs
that: The iterable providing the second half of each result pair
returns: a new mutable indexed sequence containing pairs consisting of corresponding elements of this mutable indexed sequence and that. The length of the returned collection is the minimum of the lengths of this mutable indexed sequence and that.

Definition Classes: IterableLike → GenIterableLike

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

[use case]

Returns a mutable indexed sequence formed from this mutable indexed sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.

B: the type of the second half of the returned pairs
that: The iterable providing the second half of each result pair
thisElem: the element to be used to fill up the result if this mutable indexed sequence is shorter than that.
thatElem: the element to be used to fill up the result if that is shorter than this mutable indexed sequence.
returns: a new mutable indexed sequence containing pairs consisting of corresponding elements of this mutable indexed sequence and that. The length of the returned collection is the maximum of the lengths of this mutable indexed sequence and that. If this mutable indexed sequence is shorter than that, thisElem values are used to pad the result. If that is shorter than this mutable indexed sequence, thatElem values are used to pad the result.

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex: IndexedSeq[(A, Int)]

[use case]

Zips this mutable indexed sequence with its indices.

returns: A new mutable indexed sequence containing pairs consisting of all elements of this mutable indexed sequence paired with their index. Indices start at 0.

Definition Classes: 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/mutable/IndexedSeqLike.html