Трейт scala.collection.LinearSeqLike

трейт LinearSeqLike[+A, +Repr <: LinearSeqLike[A, Repr]] extends SeqLike[A, Repr]

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

Этот трейт реализует только iterator и corresponds в терминах isEmpty, head и tail. Однако см. LinearSeqOptimized — трейт реализации, переопределяющий гораздо больше операций, чтобы они выполнялись быстрее при условии быстрого линейного доступа с помощью head и tail.

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

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

Тип Self: Repr
Источник: LinearSeqLike.scala
Версия: 2.8

Линейные суперклассы

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

Члены типов

type Self = Repr

Тип, реализующий данную обходимую коллекцию

Атрибуты: protected[this]
Классы, в которых определено: TraversableLike

class WithFilter extends FilterMonadic[A, Repr]

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

Классы, в которых определено: TraversableLike

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

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

abstract def length: Int

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

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

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

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

Классы, в которых определено: SeqLike → GenSeqLike
Выбрасываемые исключения: IllegalArgumentException, если длину последовательности нельзя представить в виде Int, например, (-1 to Int.MaxValue).length.

abstract def newBuilder: Builder[A, Repr]

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

Атрибуты: protected[this]
Классы, в которых определено: TraversableLike → HasNewBuilder

abstract def seq: LinearSeq[A]

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

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

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

Классы, в которых определено: LinearSeqLike → GenSeqLike → Parallelizable → TraversableOnce → GenTraversableOnce

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

final def !=(arg0: Any): Boolean

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

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

Классы, содержащие определение: AnyRef → Any

final def ##(): Int

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

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

Классы, содержащие определение: AnyRef → Any

def +(other: String): String

Неявный: Этот член добавлен неявным преобразованием из LinearSeqLike[A, Repr] в any2stringadd[LinearSeqLike[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]): Seq[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): Seq[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): (LinearSeqLike[A, Repr], B)

Неявный: Этот член добавлен неявным преобразованием из LinearSeqLike[A, Repr] в ArrowAssoc[LinearSeqLike[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): Seq[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 в противном случае.

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

def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

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

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

возвращает: текущий объект.

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

def canEqual(that: Any): Boolean

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

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

Классы, в которых определён метод: IterableLike → Equals

def clone(): AnyRef

Создает копию текущего объекта.

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

возвращает: копия текущего объекта.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Классы, в которых определен метод: TraversableOnce

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

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

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

Классы, в которых определен метод: LinearSeqLike → SeqLike → GenSeqLike
Аннотации: @tailrec()

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

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

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

Классы, в которых определен метод: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Классы, в которых определен метод: SeqLike → GenSeqLike

def distinct: Repr

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

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

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

Классы, в которых определен метод: SeqLike → GenSeqLike

def drop(n: Int): Repr

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

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

Классы, в которых определен метод: IterableLike → TraversableLike → GenTraversableLike

def dropRight(n: Int): Repr

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

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

Классы, в которых определен метод: IterableLike

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

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

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

Классы, в которых определен метод: TraversableLike → GenTraversableLike

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

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

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

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

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

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

Неявное преобразование: Этот элемент добавляется неявным преобразованием из LinearSeqLike[A, Repr] в Ensuring[LinearSeqLike[A, Repr]], выполняемым методом Ensuring в scala.Predef.
Классы определения: Ensuring

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

Неявное преобразование: Этот элемент добавляется неявным преобразованием из LinearSeqLike[A, Repr] в Ensuring[LinearSeqLike[A, Repr]], выполняемым методом Ensuring в scala.Predef.
Классы определения: Ensuring

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

Неявное преобразование: Этот элемент добавляется неявным преобразованием из LinearSeqLike[A, Repr] в Ensuring[LinearSeqLike[A, Repr]], выполняемым методом Ensuring в scala.Predef.
Классы определения: Ensuring

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

Неявное преобразование: Этот элемент добавляется неявным преобразованием из LinearSeqLike[A, Repr] в Ensuring[LinearSeqLike[A, Repr]], выполняемым методом Ensuring в scala.Predef.
Классы определения: Ensuring

final def eq(arg0: AnyRef): Boolean

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

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

x

y

AnyRef

x.eq(y)

true

false

x

AnyRef

x.eq(null)

null.eq(x)

false

null.eq(null)

true

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

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

Классы, определяющие: AnyRef

def equals(that: Any): Boolean

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

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

Классы, определяющие: GenSeqLike → Equals → Any

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

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

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

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

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

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

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

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

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

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

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

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

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

def finalize(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

возвращает

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def formatted(fmtstr: String): String

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

Неявное: Этот член добавляется неявным преобразованием из LinearSeqLike[A, Repr] в StringFormat[LinearSeqLike[A, Repr]] с помощью метода StringFormat в scala.Predef.
Классы-определения: StringFormat
Аннотации: @inline()

final def getClass(): Class[_]

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

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

Классы-определения: AnyRef → Any
Аннотации: @native()

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

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

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

K

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

f

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

возвращает

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

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

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

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

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

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

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

Классы, в которых определено: IterableLike
См. также: scala.collection.Iterator, метод grouped

def hasDefiniteSize: Boolean

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

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

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

Классы, в которых определено: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

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

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

Классы, в которых определено: LinearSeqLike → GenSeqLike → AnyRef → Any

def head: A

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

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

Классы, в которых определено: IterableLike → TraversableLike → GenTraversableLike
Выбрасываемые исключения: NoSuchElementException если итерируемая коллекция пуста.

def headOption: Option[A]

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

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

Классы, в которых определено: TraversableLike → GenTraversableLike

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

[use case]

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

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

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

Классы, в которых определено: GenSeqLike

def indexOf(elem: A): Int

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

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

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

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

Классы, в которых определён метод: GenSeqLike

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

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

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

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

Классы, в которых определён метод: SeqLike

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

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

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

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

Классы, в которых определён метод: SeqLike

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

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

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

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

Классы, определяющие метод: SeqLike → GenSeqLike

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

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

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

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

Классы, определяющие метод: GenSeqLike

def indices: immutable.Range

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

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

Классы, определяющие метод: SeqLike

def init: Repr

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

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

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

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

def inits: Iterator[Repr]

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

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

Классы, определяющие метод: TraversableLike

def intersect(that: Seq[A]): Seq[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]

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

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

Классы, в которых определено: LinearSeqLike → 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: последовательность для проверки
возвращает: последний индекс, такой что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1, если такой подпоследовательности не существует.

Классы, в которых определено: SeqLike

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

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

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

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

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

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

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

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

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

def lastOption: Option[A]

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

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

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

def lengthCompare(len: Int): Int

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

len

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

возвращает

Значение 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 является быстрым.

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

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

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

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

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

Классы-определения: 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: Функция измерения.
returns: Первый элемент этой последовательности с наименьшим значением, измеренным функцией f.

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

def mkString: String

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

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

Классы, в которых определено: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

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

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

Классы, в которых определено: TraversableOnce → GenTraversableOnce

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

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

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

Классы, в которых определен: TraversableOnce → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

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

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

Классы, в которых определен: AnyRef

def nonEmpty: Boolean

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

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

Классы, в которых определен: TraversableOnce → GenTraversableOnce

final def notify(): Unit

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

Классы, в которых определен: AnyRef
Аннотации: @native()
Примечание: не указано SLS как член AnyRef

final def notifyAll(): Unit

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

Классы, в которых определен: AnyRef
Аннотации: @native()
Примечание: не указано SLS как член AnyRef

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

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

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

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

Классы, в которых определен: SeqLike → GenSeqLike

def par: ParSeq[A]

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

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

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

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

возвращает: параллельная реализация этой коллекции

Классы, в которых определен: Parallelizable

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

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

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

Атрибуты: protected[this]
Классы, определяющие реализацию: SeqLike → TraversableLike → Parallelizable

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

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

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

Классы, определяющие реализацию: TraversableLike → GenTraversableLike

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

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

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

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

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

def permutations: Iterator[Repr]

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

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

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

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

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

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

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

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

def product: A

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

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

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

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

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

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

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

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

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

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

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

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

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

B

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

op

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

возвращает

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

B

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

op

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

Возвращает

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

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

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

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

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

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

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

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

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

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

def repr: Repr

Коллекция типа traversable collection, лежащая в основе этого 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): Seq[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.
возвращает: коллекция с промежуточными результатами

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

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

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

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

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

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

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

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

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

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

Классы, определяющие метод: TraversableLike → GenTraversableLike

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def stringPrefix: String

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

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

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

def sum: A

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

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

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

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

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

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

def tail: Repr

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

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

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

def tails: Iterator[Repr]

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

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

Классы, в которых определён: TraversableLike

def take(n: Int): Repr

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

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

Классы, в которых определён: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): Repr

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

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

Классы, в которых определён: IterableLike

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

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

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

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

def thisCollection: LinearSeq[A]

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

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

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

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

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

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

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

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

def toArray: Array[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

Классы, в которых определён метод: TraversableOnce → GenTraversableOnce

def toIterable: Iterable[A]

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

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

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

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

Классы, в которых определён метод: IterableLike → TraversableOnce → GenTraversableOnce

def toIterator: Iterator[A]

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

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

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

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

def toList: List[A]

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

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

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

Классы, в которых определён метод: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Классы, в которых определён метод: TraversableOnce → GenTraversableOnce

def toParArray: ParArray[T]

Неявный: Этот член добавлен неявным преобразованием из LinearSeqLike[A, Repr] в CollectionsHaveToParArray[LinearSeqLike[A, Repr], T] выполняемым методом CollectionsHaveToParArray в scala.collection.parallel. Это преобразование будет выполнено только в том случае, если неявное значение типа (LinearSeqLike[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]

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

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

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

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

def toVector: Vector[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def view: SeqView[A, Repr]

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

возвращает: нестрогое (ленивое) представление этой последовательности.

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

final def wait(): Unit

Классы-определения: AnyRef
Аннотации: @throws( ... )

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

Классы-определения: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long): Unit

Классы-определения: AnyRef
Аннотации: @throws( ... ) @native()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def zipWithIndex: Seq[(A, Int)]

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

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

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

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

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

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

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

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

Неявный

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

Затенение

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

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

(linearSeqLike: 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/LinearSeqLike.html