Trait scala.collection.LinearSeqLike

trait LinearSeqLike[+A, +Repr <: LinearSeqLike[A, Repr]] extends SeqLike[A, Repr]

A template trait for linear sequences of type LinearSeq[A].

This trait just implements iterator and corresponds in terms of isEmpty, head, and tail. However, see LinearSeqOptimized for an implementation trait that overrides many more operations to make them run faster under the assumption of fast linear access with head and tail.

Linear sequences do not add any new methods to Seq, but promise efficient implementations of linear access patterns.

A: the element type of the sequence
Repr: the type of the actual sequence containing the elements.

Self Type: Repr
Source: LinearSeqLike.scala
Since: 2.8

Linear Supertypes

Known Subclasses

Type Members

type Self = Repr

The type implementing this traversable

Attributes: protected[this]
Definition Classes: TraversableLike

class WithFilter extends FilterMonadic[A, Repr]

A class supporting filtered operations. Instances of this class are returned by method withFilter.

Definition Classes: TraversableLike

Abstract Value Members

abstract def apply(idx: Int): A

Selects an element by its index in the sequence.

Example:

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: The index to select.
returns: the element of this sequence at index idx, where 0 indicates the first element.

Definition Classes: SeqLike → GenSeqLike
Exceptions thrown: IndexOutOfBoundsException if idx does not satisfy 0 <= idx < length.

abstract def length: Int

The length of the sequence.

Note: will not terminate for infinite-sized collections.

Note: xs.length and xs.size yield the same result.

returns: the number of elements in this sequence.

Definition Classes: SeqLike → GenSeqLike
Exceptions thrown: IllegalArgumentException if the length of the sequence cannot be represented in an Int, for example, (-1 to Int.MaxValue).length.

abstract def newBuilder: Builder[A, Repr]

Creates a new builder for this collection type.

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

abstract def seq: LinearSeq[A]

A version of this collection with all of the operations implemented sequentially (i.e., in a single-threaded manner).

This method returns a reference to this collection. In parallel collections, it is redefined to return a sequential implementation of this collection. In both cases, it has O(1) complexity.

returns: a sequential view of the collection.

Definition Classes: LinearSeqLike → GenSeqLike → Parallelizable → TraversableOnce → GenTraversableOnce

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

final def !=(arg0: Any): Boolean

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

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

Definition Classes: AnyRef → Any

final def ##(): Int

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

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

Definition Classes: AnyRef → Any

def +(other: String): String

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

[use case]

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

Пример:

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

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

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

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

Definition Classes: TraversableLike

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

[use case]

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

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

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

Пример:

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

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

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

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

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

Примеры:

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

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

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

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Пример:

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: AnyRef → Any

def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

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

Definition Classes: TraversableOnce

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

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

Пример:

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

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

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

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

Definition Classes: TraversableOnce

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

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

Пример:

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

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

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

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

Definition Classes: TraversableOnce

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

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

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

final def asInstanceOf[T0]: T0

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

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

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

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

def canEqual(that: Any): Boolean

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

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

Definition Classes: IterableLike → Equals

def clone(): AnyRef

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

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

returns: копия текущего объекта.

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( ... ) @native()
Note: не задано в SLS как член AnyRef

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

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

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

Definition Classes: TraversableOnce

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce

final 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: LinearSeqLike → SeqLike → GenSeqLike
Annotations: @tailrec()

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

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

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

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

Implicit: This member is added by an implicit conversion from LinearSeqLike[A, Repr] to Ensuring[LinearSeqLike[A, Repr]] performed by method Ensuring in scala.Predef.
Definition Classes: 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).

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

Definition Classes: AnyRef

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def finalize(): Unit

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

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

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

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

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

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

Например:

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

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

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

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

B

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

z

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

op

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

возвращает

результат вставки 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

[use case]

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

Definition Classes: IterableLike
See also: 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

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

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

Definition Classes: LinearSeqLike → GenSeqLike → AnyRef → Any

def head: A

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

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

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

def headOption: Option[A]

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

[use case]

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

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

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

Definition Classes: GenSeqLike

def indexOf(elem: A): Int

[use case]

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

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

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

Definition Classes: GenSeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

Definition Classes: GenSeqLike

def indices: immutable.Range

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

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

Definition Classes: SeqLike

def init: Repr

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

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

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

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

def inits: Iterator[Repr]

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

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

Definition Classes: TraversableLike

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

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

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

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

Definition Classes: GenSeqLike

def isEmpty: Boolean

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

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes: Any

final def isTraversableAgain: Boolean

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

returns: true

Definition Classes: TraversableLike → GenTraversableLike → GenTraversableOnce

def iterator: Iterator[A]

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

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

Definition Classes: LinearSeqLike → IterableLike → GenIterableLike

def last: A

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

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

Definition Classes: 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): Seq[B]

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

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

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

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

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

[use case]

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

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

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

def min: A

[use case]

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

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

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

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

[use case]

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

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

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

def mkString: String

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

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

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

Definition Classes: AnyRef

def nonEmpty: Boolean

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

final def notify(): Unit

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

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

final def notifyAll(): Unit

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

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

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def par: ParSeq[A]

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

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

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

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

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

Definition Classes: Parallelizable

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

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

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

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def patch(from: Int, that: GenSeq[A], replaced: Int): 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: Бинарный оператор, который должен быть ассоциативным.
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

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: Repr

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reverseIterator: Iterator[A]

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reversed: List[A]

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

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

[use case]

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

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

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

Definition Classes: IterableLike → GenIterableLike

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[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: 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
See also: 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
See also: scala.math.Ordering

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

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: GenSeqLike

def stringPrefix: String

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

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

Definition Classes: TraversableLike → GenTraversableLike

def sum: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

Definition Classes: AnyRef

def tail: Repr

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

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

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

def tails: Iterator[Repr]

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

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

Definition Classes: TraversableLike

def take(n: Int): Repr

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): Repr

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

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

Definition Classes: IterableLike

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

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def thisCollection: LinearSeq[A]

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

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

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

[use case]

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toIterable: Iterable[A]

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

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

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

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

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

def toIterator: Iterator[A]

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

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

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

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

def toList: List[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toParArray: ParArray[T]

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

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

def view: SeqView[A, Repr]

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

final def wait(): Unit

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

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

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

final def wait(arg0: Long): Unit

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

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

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

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

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

Definition Classes: TraversableLike → FilterMonadic

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

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

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

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex: Seq[(A, Int)]

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

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

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