Трейт scala.collection.immutable.StreamViewLike.Sliced

trait Sliced extends StreamViewLike.Sliced with Transformed[A]

Источник: StreamViewLike.scala

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

Члены типов

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

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

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

трайт Appended[B >: A] extends StreamViewLike.Appended[B] with Transformed[B]

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

трайт DroppedWhile extends StreamViewLike.DroppedWhile with Transformed[A]

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

трайт EmptyView extends Transformed[Nothing] with StreamViewLike.EmptyView

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

трайт Filtered extends StreamViewLike.Filtered with Transformed[A]

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

трайт FlatMapped[B] extends StreamViewLike.FlatMapped[B] with Transformed[B]

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

трайт Forced[B] extends StreamViewLike.Forced[B] with Transformed[B]

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

трайт Mapped[B] extends StreamViewLike.Mapped[B] with Transformed[B]

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

трайт Patched[B >: A] extends StreamViewLike.Patched[B] with Transformed[B]

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

трайт Prepended[B >: A] extends StreamViewLike.Prepended[B] with Transformed[B]

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

трайт Reversed extends StreamViewLike.Reversed with Transformed[A]

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

трайт Sliced extends StreamViewLike.Sliced with Transformed[A]

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

тип Self = StreamView[A, Coll]

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

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

тракт TakenWhile extends StreamViewLike.TakenWhile with Transformed[A]

Определения классов: StreamViewLike

тракт Transformed[+B] extends StreamView[B, Coll] with StreamViewLike.Transformed[B]

Определения классов: StreamViewLike

тракт Zipped[B] extends StreamViewLike.Zipped[B] with Transformed[(A, B)]

Определения классов: StreamViewLike

тракт ZippedAll[A1 >: A, B] extends StreamViewLike.ZippedAll[A1, B] with Transformed[(A1, B)]

Определения классов: StreamViewLike

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

абстрактный val endpoints: SliceInterval

Атрибуты: protected[this]
Определения классов: Sliced

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

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

Неявный: Этот член добавлен благодаря неявной конверсии из Sliced в any2stringadd[Sliced] посредством метода any2stringadd в scala.Predef.
Definition Classes: any2stringadd

def ++[B >: A, That](xs: GenTraversableOnce[B])(implicit bf: CanBuildFrom[StreamView[A, Coll], B, That]): That

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

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

Definition Classes: TraversableViewLike → 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: TraversableViewLike → 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: SeqViewLike → SeqLike → GenSeqLike

def ->[B](y: B): (Sliced, B)

Неявный: Этот член добавлен с помощью неявного преобразования из Sliced в ArrowAssoc[Sliced], выполненного методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc
Аннотации: @inline()

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

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

Примечание: /: — это альтернативная синтаксическая форма для foldLeft; z /: xs — это то же самое, что и xs foldLeft z.

Примеры:

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

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

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

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def :+(elem: A): 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: SeqViewLike → 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, start: String, sep: String, end: String): StringBuilder

Definition Classes: ViewMkString

def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

def andThen[C](k: (A) ⇒ C): PartialFunction[Int, C]

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

C: тип результата функции преобразования.
k: функция преобразования
возвращает: частичная функция с тем же областью определения, что и эта частичная функция, которая отображает аргументы x в k(this(x)).

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

def apply(idx: Int): A

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

Пример:

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

scala> x(3)
res1: Int = 4

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

Определяющие классы: Sliced → Transformed → SeqLike → GenSeqLike → Function1
Исключения: IndexOutOfBoundsException, если idx не удовлетворяет 0 <= idx < length.

def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) ⇒ B1): B1

Applies this partial function to the given argument if it's contained in the function's domain. Applies the fallback function if this partial function is undefined.

Note that the expression pf.applyOrElse(x, default) is equivalent to

if(pf isDefinedAt x) pf(x) else default(x)

except that the method applyOrElse can be implemented more efficiently. For all partial function literals, the compiler generates an implementation of applyOrElse, which avoids redundant recomputation of pattern matches and conditions. This makes applyOrElse the basis for an efficient implementation in many operations and scenarios such as:

orElse

andThen

apply

isDefinedAt

lift

unlift

runWith

For non-literal classes of partial functions with a nontrivial method isDefinedAt, it's recommended to override applyOrElse with a custom implementation that avoids redundant recomputation of isDefinedAt. This can lead to performance improvements and more predictable behavior concerning side effects.

x: function argument
default: fallback function
возвращает: result of applying this function or the fallback function.

Определяющие классы: PartialFunction
Cкаляр: 2.10

final def asInstanceOf[T0]: T0

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

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

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

Definition Classes: Any
Исключения: 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
Аннотации: @throws( ... ) @native()
Примечание: не определен в SLS как член AnyRef

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

[use case]

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

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

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

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

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

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

Definition Classes: TraversableOnce

def combinations(n: Int): Iterator[StreamView[A, Coll]]

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

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

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

Definition Classes: SeqViewLike → SeqLike

def companion: GenericCompanion[collection.Seq]

Объект-компаньон-фабрика, который создает экземпляры класса Seq. (или его Iterable суперкласса, где класс Seq не является Seq.)

Definition Classes: Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate

def compose[A](g: (A) ⇒ Int): (A) ⇒ A

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

A: тип, к которому можно применить функцию g
g: функция A => T1
returns: новая функция f, такая что f(x) == apply(g(x))

Definition Classes: Function1
Annotations: @unspecialized()

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

Копирует все элементы этой последовательности или итератора в буфер.

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

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

Definition Classes: TraversableOnce

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

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

[use case]

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

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

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

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

def distinct: StreamView[A, Coll]

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

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

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

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

def drop(n: Int): StreamView[A, Coll]

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

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

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

def dropRight(n: Int): StreamView[A, Coll]

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

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

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

def dropWhile(p: (A) ⇒ Boolean): StreamView[A, Coll]

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

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

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

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

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

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

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

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

def ensuring(cond: (Sliced) ⇒ Boolean, msg: ⇒ Any): Sliced

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

def ensuring(cond: (Sliced) ⇒ Boolean): Sliced

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

def ensuring(cond: Boolean, msg: ⇒ Any): Sliced

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

def ensuring(cond: Boolean): Sliced

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

final def eq(arg0: AnyRef): Boolean

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

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

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

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

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

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

def equals(that: Any): Boolean

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

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

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

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

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

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

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

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

def filter(p: (A) ⇒ Boolean): StreamView[A, Coll]

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

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

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

def filterNot(p: (A) ⇒ Boolean): StreamView[A, Coll]

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

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

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

def finalize(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

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

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

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

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

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

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

def flatten[B]: Seq[B]

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

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

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

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

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

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

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

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

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

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

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

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

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

B

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

z

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

op

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

возвращает

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

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

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

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

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

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def force[B >: A, That](implicit bf: CanBuildFrom[Coll, B, That]): That

Definition Classes: StreamViewLike → TraversableViewLike

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

[use case]

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

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

Definition Classes: Sliced → Transformed → IterableLike → Sliced → Transformed → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def formatted(fmtstr: String): String

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

Неявный: Этот член добавляется неявным преобразованием из Sliced в StringFormat[Sliced] выполненным методом StringFormat в scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

def from: Int

Attributes: protected[this]
Definition Classes: Sliced

def genericBuilder[B]: Builder[B, collection.Seq[B]]

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

Definition Classes: GenericTraversableTemplate

final def getClass(): Class[_]

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

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

Definition Classes: AnyRef → Any
Annotations: @native()

def groupBy[K](f: (A) ⇒ K): Map[K, StreamView[A, Coll]]

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

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

K

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

f

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

возвращает

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

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

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

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

def grouped(size: Int): Iterator[StreamView[A, Coll]]

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

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

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

def hasDefiniteSize: Boolean

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

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

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

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

def hashCode(): Int

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

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

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

def head: A

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

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

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

def headOption: Option[A]

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

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

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

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

[use case]

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

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

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

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

def indexOf(elem: A): Int

[use case]

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

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

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

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

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

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

Definition Classes: SeqLike

def init: StreamView[A, Coll]

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

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike
Exceptions thrown: UnsupportedOperationException, если коллекция пуста.

def inits: Iterator[StreamView[A, Coll]]

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

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

Definition Classes: TraversableViewLike → TraversableLike

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

[use case]

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

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

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

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

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

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

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

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

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

def last: A

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

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

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

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

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

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

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

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

def length: Int

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

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

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

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

Definition Classes: Sliced → Transformed → SeqLike → GenSeqLike
Exceptions thrown: IllegalArgumentException, если длина последовательности не может быть представлена в Int, например, (-1 to Int.MaxValue).length.

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 lift: (Int) ⇒ Option[A]

Преобразует эту частичную функцию в обычную функцию, возвращающую результат Option.

returns: функция, которая принимает аргумент x к Some(this(x)) если this определено для x, и к None в противном случае.

Definition Classes: PartialFunction
See also: Function.unlift

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

[use case]

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта последовательность пуста.

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

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта последовательность пуста.

def min: A

[служебный случай]

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

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

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

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

[служебный случай]

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

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

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

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

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

def mkString(sep: String): String

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

def mkString: String

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

final def ne(arg0: AnyRef): Boolean

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

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

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

def newAppended[B >: A](that: GenTraversable[B]): Transformed[B]

Атрибуты: protected
Определяющие классы: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newBuilder: Builder[A, StreamView[A, Coll]]

Создатель экземпляров типа Traversable[A]

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

def newDropped(n: Int): Sliced.Transformed[A]

Атрибуты: protected
Определяющие классы: SeqViewLike → IterableViewLike → TraversableViewLike

def newDroppedWhile(p: (A) ⇒ Boolean): Transformed[A]

Атрибуты: protected
Определяющие классы: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newFiltered(p: (A) ⇒ Boolean): Transformed[A]

Атрибуты: protected
Определяющие классы: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newFlatMapped[B](f: (A) ⇒ GenTraversableOnce[B]): Transformed[B]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newForced[B](xs: ⇒ GenSeq[B]): Transformed[B]

шаблон

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newMapped[B](f: (A) ⇒ B): Transformed[B]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newPatched[B >: A](_from: Int, _patch: GenSeq[B], _replaced: Int): Transformed[B]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike

def newPrepended[B >: A](that: GenTraversable[B]): Transformed[B]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newReversed: Transformed[A]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike

def newSliced(_endpoints: SliceInterval): Transformed[A]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newTaken(n: Int): Sliced.Transformed[A]

Атрибуты: protected
Классы-определения: SeqViewLike → IterableViewLike → TraversableViewLike

def newTakenWhile(p: (A) ⇒ Boolean): Transformed[A]

Атрибуты: protected
Классы-определения: StreamViewLike → SeqViewLike → IterableViewLike → TraversableViewLike

def newZipped[B](that: GenIterable[B]): Transformed[(A, B)]

Шаблонный метод, который необходимо переопределить в каждом подклассе. Этот метод можно было бы исключить, если бы в Scala были виртуальные классы

Атрибуты: protected
Определяющие классы: StreamViewLike → SeqViewLike → IterableViewLike

def newZippedAll[A1 >: A, B](that: GenIterable[B], _thisElem: A1, _thatElem: B): Transformed[(A1, B)]

Атрибуты: protected
Определяющие классы: StreamViewLike → SeqViewLike → IterableViewLike

def nonEmpty: Boolean

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

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

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

final def notify(): Unit

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

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

final def notifyAll(): Unit

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

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

def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

A1: тип аргумента резервной функции
B1: тип возвращаемого значения резервной функции
that: резервная функция
возвращает: частичная функция, область определения которой является объединением областей определения данной частичной функции и данной функции. Результирующая частичная функция принимает аргумент к данной функции, если она определена, и к резервной функции в противном случае.

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

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

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

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

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

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

def par: ParSeq[A]

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

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

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

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

возвращает: параллельная реализация данного набора

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

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

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

returns: комбинирующее выражение для параллельной коллекции типа ParRepr

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

def partition(p: (A) ⇒ Boolean): (StreamView[A, Coll], StreamView[A, Coll])

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

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

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

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

[use case]

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

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

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

def permutations: Iterator[StreamView[A, Coll]]

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

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

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

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

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

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

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

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

def product: A

[use case]

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

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

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

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

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

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

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

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

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

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

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

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

B

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

op

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

returns

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

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

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

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

B

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

op

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

returns

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

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

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

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def repr: StreamView[A, Coll]

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: StreamView[A, Coll]

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

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

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

Definition Classes: SeqViewLike → 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: SeqViewLike → SeqLike → GenSeqLike

def reversed: scala.List[A]

Attributes: protected[this]
Definition Classes: TraversableOnce

def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

action: функция действия
returns: функция, которая отображает аргументы x в isDefinedAt(x). Результирующая функция выполняет action(this(x)) там, где this определена.

Definition Classes: PartialFunction
Since: 2.10
См. также: applyOrElse.

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[StreamView[A, Coll], 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[StreamView[A, Coll], B, That]): That

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

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

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[StreamView[A, Coll], 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: TraversableViewLike → 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 seq: collection.Seq[A]

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

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

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

Definition Classes: Seq → GenSeq → GenSeqLike → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce

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): StreamView[A, Coll]

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

from <= indexOf(x) < until

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def sliding(size: Int): Iterator[StreamView[A, Coll]]

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

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

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

def sliding(size: Int, step: Int): Iterator[StreamView[A, Coll]]

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

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

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

def sortBy[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): StreamView[A, Coll]

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

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

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

def sortWith(lt: (A, A) ⇒ Boolean): StreamView[A, Coll]

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

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

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

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

Definition Classes: SeqViewLike → SeqLike

def sorted[B >: A](implicit ord: Ordering[B]): StreamView[A, Coll]

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

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

Definition Classes: SeqViewLike → SeqLike
See also: scala.math.Ordering

def span(p: (A) ⇒ Boolean): (StreamView[A, Coll], StreamView[A, Coll])

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

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

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

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

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

def splitAt(n: Int): (StreamView[A, Coll], StreamView[A, Coll])

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

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

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

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

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

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

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

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

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

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

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

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

def stringPrefix: String

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

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

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

def sum: A

[use case]

Суммирует элементы этого множества.

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

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

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

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

def tail: StreamView[A, Coll]

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

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

Определяющие классы: TraversableViewLike → TraversableLike → GenTraversableLike
Исключения: java.lang.UnsupportedOperationException, если множество пустое.

def tails: Iterator[StreamView[A, Coll]]

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

возвращает: итератор по всем хвостам этого множества

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

def take(n: Int): StreamView[A, Coll]

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

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

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

Definition Classes: IterableViewLike → TraversableViewLike → IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): StreamView[A, Coll]

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

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

Definition Classes: IterableViewLike → IterableLike

def takeWhile(p: (A) ⇒ Boolean): StreamView[A, Coll]

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def thisCollection: collection.Seq[A]

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

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

def thisSeq: collection.Seq[A]

Attributes: protected[this]
Definition Classes: ViewMkString

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

[use case]

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toCollection(repr: StreamView[A, Coll]): collection.Seq[A]

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

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

def toIndexedSeq: IndexedSeq[A]

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

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

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

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

def toIterable: collection.Iterable[A]

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

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

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

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

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

def toIterator: Iterator[A]

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

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

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

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

def toList: scala.List[A]

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

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

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

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

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

[use case]

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

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

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

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

def toParArray: ParArray[T]

Неявный: Этот член добавлен неявно при преобразовании из Sliced в CollectionsHaveToParArray[Sliced, T] методом CollectionsHaveToParArray в scala.collection.parallel. Это преобразование произойдет только если в области видимости имеется неявное значение типа (Sliced) ⇒ GenTraversableOnce[T].
Классы-определения: CollectionsHaveToParArray

def toSeq: collection.Seq[A]

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

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

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

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

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

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

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

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

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

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

def toStream: Stream[A]

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

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

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

def toString(): String

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

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

Определяющие классы: Transformed → Transformed → Transformed → Transformed → TraversableViewLike → SeqLike → TraversableLike → Function1 → AnyRef → Any

def toTraversable: collection.Traversable[A]

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

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

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

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

def toVector: scala.Vector[A]

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

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

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

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

def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): collection.Seq[collection.Seq[B]]

Транспонирует эту коллекцию коллекций Traversable в коллекцию коллекций.

Тип результирующей коллекции будет определяться статическим типом коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

Определяющие классы: GenericTraversableTemplate
Аннотации: @migration
Миграция: (Изменено в версии 2.9.0) transpose вызывает IllegalArgumentException если размеры коллекций не одинаковы.
Исключения: IllegalArgumentException, если все коллекции в этой коллекции не имеют одинаковый размер.

lazy val underlying: Coll

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

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

[use case]

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

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

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

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

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

def until: Int

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

def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Sliced.Transformed[A1], Sliced.Transformed[A2])

Преобразует эту коллекцию пар в две коллекции первой и второй половины каждой пары.

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

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

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

def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Sliced.Transformed[A1], Sliced.Transformed[A2], Sliced.Transformed[A3])

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

val xs = Traversable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three),
//        Traversable(1, 2, 3))

A1: тип первого члена кортежей-элементов
A2: тип второго члена кортежей-элементов
A3: тип третьего члена кортежей-элементов
asTriple: явное преобразование, утверждающее, что тип элементов этого набора — кортеж из трёх элементов.
returns: тройка наборов, содержащих первый, второй и третий члены каждого кортежа-элемента этого набора.

Definition Classes: TraversableViewLike → GenericTraversableTemplate

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

[use case]

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

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

Создаёт нестрогий вид слайса этого массива.

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

Создаёт нестрогое представление этого массива.

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

Definition Classes: SeqLike → IterableLike → TraversableLike

final def viewIdString: String

Attributes: protected[this]
Definition Classes: Transformed → TraversableViewLike

final def viewIdentifier: String

Attributes: protected[this]
Definition Classes: Sliced → TraversableViewLike

def viewToString: String

Definition Classes: TraversableViewLike

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): StreamView[A, Coll]

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

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

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

Definition Classes: TraversableViewLike → TraversableLike → FilterMonadic

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

[use case]

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

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

Definition Classes: IterableViewLike → IterableLike → GenIterableLike

def zipAll[B](that: collection.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: IterableViewLike → IterableLike → GenIterableLike

def zipWithIndex: Seq[(A, Int)]

[use case]

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

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

Definition Classes: IterableViewLike → IterableLike → GenIterableLike

def →[B](y: B): (Sliced, B)

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

Скрытые неявные члены значения

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

Неявный

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

Скрытие

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

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

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

MonadOps

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

Неявный

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

Скрытие

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

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

MonadOps

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

Неявный

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

Скрытие

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

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

MonadOps

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

Неявный

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

Скрытие

(sliced: 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/immutable/StreamViewLike$Sliced.html