Трейт scala.collection.LinearSeqOptimized

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

Шаблонный трейт для линейных последовательностей типа LinearSeq[A], который оптимизирует реализацию различных методов при условии быстрого линейного доступа.

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

def isEmpty: Boolean
def head: A
def tail: Repr

Здесь A — тип элементов последовательности, а Repr — тип самой последовательности. Обратите внимание, что по умолчанию реализации предоставляются через наследование, но для повышения производительности их следует переопределить.

Self Type: Repr
Source: LinearSeqOptimized.scala

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

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

Типовые Члены

тип Self = Repr

Тип, реализующий этот итерируемый объект

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

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

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

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

Абстрактные Значения Членов

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

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

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

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

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

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

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

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

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

A copy of the sequence with an element prepended.

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Also, the original sequence is not modified, so you will want to capture the result.

Example:

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: the prepended element
returns: a new sequence consisting of elem followed by all elements of this sequence.

Definition Classes: SeqLike → GenSeqLike

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

Implicit: This member is added by an implicit conversion from LinearSeqOptimized[A, Repr] to ArrowAssoc[LinearSeqOptimized[A, Repr]] performed by method ArrowAssoc in scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @inline()

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

Applies a binary operator to a start value and all elements of this traversable or iterator, going left to right.

Note: /: is alternate syntax for foldLeft; z /: xs is the same as xs foldLeft z.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

B

the result type of the binary operator.

z

the start value.

op

the binary operator.

returns

the result of inserting op between consecutive elements of this traversable or iterator, going left to right with the start value z on the left:

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

where x₁, ..., x_n are the elements of this traversable or iterator.

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

A copy of this sequence with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Note: will not terminate for infinite-sized collections.

Example:

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: the appended element
returns: a new sequence consisting of all elements of this sequence followed by elem.

Definition Classes: SeqLike → GenSeqLike

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

Applies a binary operator to all elements of this traversable or iterator and a start value, going right to left.

Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute c.

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

the result type of the binary operator.

z

the start value

op

the binary operator

returns

the result of inserting op between consecutive elements of this traversable or iterator, going right to left with the start value z on the right:

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

where x₁, ..., x_n are the elements of this traversable or iterator.

Definition Classes: TraversableOnce → GenTraversableOnce

final def ==(arg0: Any): Boolean

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

returns: true if the receiver object is equivalent to the argument; false otherwise.

Definition Classes: AnyRef → Any

def addString(b: StringBuilder): StringBuilder

Appends all elements of this traversable or iterator to a string builder. The written text consists of the string representations (w.r.t. the method toString) of all elements of this traversable or iterator without any separator string.

Example:

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: the string builder to which elements are appended.
returns: the string builder b to which elements were appended.

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, к которому были добавлены элементы.

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

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

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

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

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

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

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

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

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

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

def apply(n: Int): A

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

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

Определяющие классы: LinearSeqOptimized → SeqLike → GenSeqLike
Выбрасываемые исключения: IndexOutOfBoundsException если idx не удовлетворяет 0 <= idx < length.

final def asInstanceOf[T0]: T0

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

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

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

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

def canEqual(that: Any): Boolean

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

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

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

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

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

[use case]

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

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

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

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

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

[use case]

Копирует элементы этой последовательности в массив. Заполняет заданный массив 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 другой последовательности, в противном случае 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 отрицательно, не удалять ни одного элемента.

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

def dropRight(n: Int): Repr

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

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

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

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

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

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

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

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

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

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

возвращает: 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

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

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

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

[use case]

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

Например:

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

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

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

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: LinearSeqOptimized → TraversableOnce → GenTraversableOnce

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: LinearSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce

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

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

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

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

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

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

[use case]

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

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

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

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

def formatted(fmtstr: String): String

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

Неявный: Этот член добавлен неявным преобразованием из LinearSeqOptimized[A, Repr] в StringFormat[LinearSeqOptimized[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: начальный индекс
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: LinearSeqOptimized → 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
Exceptions thrown: UnsupportedOperationException, если обобщенная коллекция пуста.

def inits: Iterator[Repr]

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

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

Definition Classes: TraversableLike

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

[use case]

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

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

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

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

def isDefinedAt(x: Int): Boolean

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

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

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

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

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

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

Классы определений: LinearSeqOptimized → TraversableLike → GenTraversableLike
Исключения: NoSuchElementException Если последовательность пуста.

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

[use case]

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

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

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

def lastIndexOf(elem: A): Int

[use case]

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

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

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, если такая подпоследовательность не существует.

Definition Classes: SeqLike

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

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

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

Definition Classes: LinearSeqOptimized → SeqLike → GenSeqLike

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

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

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

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

Definition Classes: GenSeqLike

def lastOption: Option[A]

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def length: Int

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

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

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

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

Definition Classes: LinearSeqOptimized → SeqLike → GenSeqLike

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 является недорогим.

Definition Classes: LinearSeqOptimized → SeqLike

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

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

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

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

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

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

[use case]

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

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

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

def min: A

[use case]

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

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

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

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

[use case]

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

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

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

def mkString: String

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

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

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

def mkString(sep: String): String

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

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

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

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

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

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

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

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]

[use case]

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

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

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def permutations: Iterator[Repr]

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: GenSeqLike

def product: A

[use case]

Перемножает элементы этого набора.

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

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

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

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

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

B

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

op

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

returns

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

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

где x₁, ..., x_n — элементы этой последовательности.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def repr: Repr

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

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

def reverse: Repr

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

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

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

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

def reverseIterator: Iterator[A]

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reversed: List[A]

Attributes: protected[this]
Definition Classes: TraversableOnce

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

[use case]

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

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

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

Definition Classes: LinearSeqOptimized → 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: новая коллекция типа traversable, содержащая префиксное сканирование элементов в этой коллекции типа traversable

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: LinearSeqOptimized → 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: LinearSeqOptimized → 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.
возвращает: последовательность, состоящую из элементов этой последовательности, отсортированных в соответствии с порядком, где x < y если ord.lt(f(x), f(y)).

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

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

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

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

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

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

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

Definition Classes: LinearSeqOptimized → 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.

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

Definition Classes: 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

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

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

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

def tails: Iterator[Repr]

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

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

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

def take(n: Int): Repr

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

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

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

def takeRight(n: Int): Repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def toParArray: ParArray[T]

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

def toSeq: Seq[A]

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

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

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

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

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

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

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

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

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]

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

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

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

def view: SeqView[A, Repr]

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

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]

Создаёт нестрогое фильтрование этого итерируемого набора.

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

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

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

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

Неявный

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

Затенение

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

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

(linearSeqOptimized: 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/LinearSeqOptimized.html