Трейт scala.collection.SeqViewLike.EmptyView

trait EmptyView extends Transformed[Nothing] with SeqViewLike.EmptyView

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

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

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

Члены типа

тракт Appended[B >: A] extends SeqViewLike.Appended[B] with Transformed[B]

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

тракт DroppedWhile extends SeqViewLike.DroppedWhile with Transformed[A]

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

тракт EmptyView extends Transformed[Nothing] with SeqViewLike.EmptyView

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

тип Self = SeqView[Nothing, Coll]

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

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

тракт Filtered extends SeqViewLike.Filtered with Transformed[A]

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

тракт FlatMapped[B] extends SeqViewLike.FlatMapped[B] with Transformed[B]

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

тракт Forced[B] extends SeqViewLike.Forced[B] with Transformed[B]

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

тракт Mapped[B] extends SeqViewLike.Mapped[B] with Transformed[B]

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

тракт Patched[B >: A] extends Transformed[B]

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

тракт Prepended[B >: A] extends SeqViewLike.Prepended[B] with Transformed[B]

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

тракт Reversed extends Transformed[A]

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

тракт Sliced extends SeqViewLike.Sliced with Transformed[A]

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

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

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

тракт Transformed[+B] extends SeqView[B, Coll] with SeqViewLike.Transformed[B]

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

trait Zipped[B] extends SeqViewLike.Zipped[B] with Transformed[(A, B)]

Definition Classes: SeqViewLike

trait ZippedAll[A1 >: A, B] extends SeqViewLike.ZippedAll[A1, B] with Transformed[(A1, B)]

Definition Classes: SeqViewLike

class WithFilter extends FilterMonadic[A, Repr]

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

Definition Classes: TraversableLike

Члены-значения

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

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

def ++[B >: Nothing, That](xs: GenTraversableOnce[B])(implicit bf: CanBuildFrom[SeqView[Nothing, 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 >: Nothing, That](xs: Traversable[B])(implicit bf: CanBuildFrom[SeqView[Nothing, 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]

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

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

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

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

Пример:

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

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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

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

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

Неявный: Этот член добавлен неявным преобразованием из EmptyView в ArrowAssoc[EmptyView] посредством метода ArrowAssoc в scala.Predef.
Классы-определения: ArrowAssoc
Аннотации: @inline()

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

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

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

Примеры:

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

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

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

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

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

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

B

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

z

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

op

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

возвращает

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

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

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

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

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

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

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

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

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

Пример:

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

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

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

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

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

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

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

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

Примеры:

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

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

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

B

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

z

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

op

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

возвращает

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

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

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

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

final def ==(arg0: Any): Boolean

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

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

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

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

Классы-определения: 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, Nothing) ⇒ 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: (Nothing) ⇒ C): PartialFunction[Int, C]

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

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

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

final def apply(n: Int): Nothing

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

Пример:

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, где 0 обозначает первый элемент.

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

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

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

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

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

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

orElse

andThen

apply

isDefinedAt

lift

unlift

runWith

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

x: аргумент функции
default: функция обратного вызова
возвращает: результат применения этой функции или функции обратного вызова.

Определяющие классы: PartialFunction
С момента: 2.10

final def asInstanceOf[T0]: T0

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

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

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

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

def canEqual(that: Any): Boolean

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

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

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

def clone(): AnyRef

Создать копию получаемого объекта.

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

returns: копия получаемого объекта.

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

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

[use case]

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

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

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

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

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

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

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

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

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

def combinations(n: Int): Iterator[SeqView[Nothing, Coll]]

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

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

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

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

def companion: GenericCompanion[Seq]

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

Определяющие классы: Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate

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

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

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

Definition Classes: Function1
Annotations: @unspecialized()

def contains[A1 >: Nothing](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 >: Nothing](dest: Buffer[B]): Unit

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

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

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

Definition Classes: TraversableOnce

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

def distinct: SeqView[Nothing, Coll]

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

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

def drop(n: Int): SeqView[Nothing, Coll]

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

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

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

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

def dropRight(n: Int): SeqView[Nothing, Coll]

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

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

Definition Classes: IterableViewLike → IterableLike

def dropWhile(p: (Nothing) ⇒ Boolean): SeqView[Nothing, Coll]

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

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

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

def ensuring(cond: Boolean): EmptyView

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

final def eq(arg0: AnyRef): Boolean

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

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

x

y

AnyRef

x.eq(y)

true

false

x

AnyRef

x.eq(null)

null.eq(x)

false

null.eq(null)

true

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

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

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

def equals(that: Any): Boolean

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

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

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

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

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

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

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

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

def filter(p: (Nothing) ⇒ Boolean): SeqView[Nothing, Coll]

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

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

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

def filterNot(p: (Nothing) ⇒ Boolean): SeqView[Nothing, Coll]

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

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

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

def finalize(): Unit

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

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

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

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

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

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

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

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

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

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

[use case]

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

Например:

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

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

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

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

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

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

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

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

def flatten[B]: Seq[B]

[use case]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

B

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

z

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

op

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

возвращает

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

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

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

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

def foldRight[B](z: B)(op: (Nothing, 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: (Nothing) ⇒ Boolean): Boolean

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

Definition Classes: TraversableViewLike

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

[use case]

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

Definition Classes: EmptyView → Transformed → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def formatted(fmtstr: String): String

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

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

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

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

Definition Classes: GenericTraversableTemplate

final def getClass(): Class[_]

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

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

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

def groupBy[K](f: (Nothing) ⇒ K): immutable.Map[K, SeqView[Nothing, Coll]]

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

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

K

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

f

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

returns

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

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

def grouped(size: Int): Iterator[SeqView[Nothing, Coll]]

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

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

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

def hasDefiniteSize: Boolean

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

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

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

Definition Classes: GenSeqLike → Any

def head: Nothing

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

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

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

def headOption: Option[Nothing]

Возвращает необязательный первый элемент.

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

Definition Classes: Transformed → TraversableLike → GenTraversableLike

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

[use case]

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

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

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

Definition Classes: GenSeqLike

def indexOf(elem: Nothing): Int

[use case]

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

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

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

Definition Classes: GenSeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

Definition Classes: GenSeqLike

def indices: immutable.Range

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

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

Definition Classes: SeqLike

def init: SeqView[Nothing, Coll]

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

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

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

def inits: Iterator[SeqView[Nothing, Coll]]

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

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

Definition Classes: TraversableViewLike → TraversableLike

def intersect(that: 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

final def isEmpty: Boolean

Проверяет, пуста ли эта коллекция.

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

Definition Classes: EmptyView → GenericTraversableTemplate → TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes: Any

final def isTraversableAgain: Boolean

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

returns: true

Definition Classes: TraversableLike → GenTraversableLike → GenTraversableOnce

final def iterator: Iterator[Nothing]

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

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

Definition Classes: EmptyView → Transformed → IterableLike → GenIterableLike

def last: Nothing

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

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

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

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

[use case]

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

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

Definition Classes: GenSeqLike

def lastIndexOf(elem: Nothing): Int

[use case]

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

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

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

Definition Classes: GenSeqLike

def lastIndexOfSlice[B >: Nothing](that: GenSeq[B], end: Int): Int

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

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

Definition Classes: SeqLike

def lastIndexOfSlice[B >: Nothing](that: GenSeq[B]): Int

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

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

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

Definition Classes: SeqLike

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

Definition Classes: GenSeqLike

def lastOption: Option[Nothing]

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

returns: последний элемент этой коллекции$ если она непуста, None если она пуста.

Definition Classes: Transformed → TraversableLike → GenTraversableLike

final def length: Int

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

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

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

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

Definition Classes: EmptyView → Transformed → SeqLike → GenSeqLike
Исключения: 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[Nothing]

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

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

Definition Classes: PartialFunction
См. также: 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
Исключения: UnsupportedOperationException, если эта последовательность пуста.

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

[use case]

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

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

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

def min: A

[use case]

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

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

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

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

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

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

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

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

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

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

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

def newBuilder: Builder[Nothing, SeqView[Nothing, Coll]]

Построитель, создающий экземпляры типа Traversable[A]

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

def newDropped(n: Int): Transformed[Nothing]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def newReversed: Transformed[Nothing]

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

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

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

def newTaken(n: Int): Transformed[Nothing]

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

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

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

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

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

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

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

def nonEmpty: Boolean

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

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

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

final def notify(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Note: не определён SLS как член AnyRef

final def notifyAll(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Note: не определён SLS как член AnyRef

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

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

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

Definition Classes: PartialFunction

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

[use case]

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

def par: ParSeq[Nothing]

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

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

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

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

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

Definition Classes: Parallelizable

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

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

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

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

def partition(p: (Nothing) ⇒ Boolean): (SeqView[Nothing, Coll], SeqView[Nothing, Coll])

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

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

[use case]

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

def permutations: Iterator[SeqView[Nothing, Coll]]

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

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

Definition Classes: SeqViewLike → SeqLike

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

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

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

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

Definition Classes: GenSeqLike

def product: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

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

def reduceLeft[B >: Nothing](op: (B, Nothing) ⇒ 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 >: Nothing](op: (B, Nothing) ⇒ B): Option[B]

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceRight[B >: Nothing](op: (Nothing, 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
Exceptions thrown: UnsupportedOperationException если этот итерируемый набор пуст.

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def repr: SeqView[Nothing, Coll]

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: SeqView[Nothing, Coll]

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

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

def reverseIterator: Iterator[Nothing]

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

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

Примечание: 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: List[Nothing]

Attributes: protected[this]
Definition Classes: TraversableOnce

def runWith[U](action: (Nothing) ⇒ 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

[полезный случай]

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

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

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

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

def scan[B >: Nothing, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[SeqView[Nothing, Coll], B, That]): That

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

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

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

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

def scanLeft[B, That](z: B)(op: (B, Nothing) ⇒ B)(implicit bf: CanBuildFrom[SeqView[Nothing, Coll], B, That]): That

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

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

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

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

def scanRight[B, That](z: B)(op: (Nothing, B) ⇒ B)(implicit bf: CanBuildFrom[SeqView[Nothing, 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.
возвращает: коллекция с промежуточными результатами

Определяющие классы: TraversableViewLike → TraversableLike → GenTraversableLike
Аннотации: @migration
Миграция: (Изменено в версии 2.9.0) Поведение scanRight изменилось. Предыдущее поведение можно воспроизвести с помощью scanRight.reverse.

def segmentLength(p: (Nothing) ⇒ Boolean, from: Int): Int

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

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

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

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

def seq: Seq[Nothing]

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

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

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

Определяющие классы: Seq → GenSeq → GenSeqLike → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce

def size: Int

Размер этой последовательности, эквивалентный length.

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

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

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

def sizeHintIfCheap: Int

Размер этого набора данных или итератора, если он может быть вычислен дёшево.

возвращает: количество элементов в этом наборе данных или итераторе, или -1, если размер не может быть определён дёшево

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

def slice(from: Int, until: Int): SeqView[Nothing, Coll]

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

from <= indexOf(x) < until

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

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

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

def sliding(size: Int): Iterator[SeqView[Nothing, Coll]]

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

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

Определяющие классы: IterableViewLike → IterableLike
См. также: scala.collection.Iterator, метод sliding

def sliding(size: Int, step: Int): Iterator[SeqView[Nothing, Coll]]

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

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

Определяющие классы: IterableViewLike → IterableLike
См. также: scala.collection.Iterator, метод sliding

def sortBy[B](f: (Nothing) ⇒ B)(implicit ord: Ordering[B]): SeqView[Nothing, Coll]

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

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

Определяющие классы: SeqViewLike → SeqLike
См. также: scala.math.Ordering Примечание: не завершится для наборов данных бесконечного размера.

def sortWith(lt: (Nothing, Nothing) ⇒ Boolean): SeqView[Nothing, Coll]

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

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

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

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

Definition Classes: SeqViewLike → SeqLike

def sorted[B >: Nothing](implicit ord: Ordering[B]): SeqView[Nothing, Coll]

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

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

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

def span(p: (Nothing) ⇒ Boolean): (SeqView[Nothing, Coll], SeqView[Nothing, Coll])

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

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

def splitAt(n: Int): (SeqView[Nothing, Coll], SeqView[Nothing, Coll])

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: GenSeqLike

def stringPrefix: String

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

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

Definition Classes: Transformed → TraversableViewLike → TraversableLike → GenTraversableLike

def sum: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

Definition Classes: AnyRef

def tail: SeqView[Nothing, Coll]

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

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

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

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

def tails: Iterator[SeqView[Nothing, Coll]]

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

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

Definition Classes: TraversableViewLike → TraversableLike

def take(n: Int): SeqView[Nothing, Coll]

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

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

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

def takeRight(n: Int): SeqView[Nothing, Coll]

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

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

Definition Classes: IterableViewLike → IterableLike

def takeWhile(p: (Nothing) ⇒ Boolean): SeqView[Nothing, Coll]

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

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

Definition Classes: TraversableViewLike → TraversableLike → GenTraversableLike

def thisCollection: Seq[Nothing]

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

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

def thisSeq: Seq[Nothing]

Attributes: protected[this]
Definition Classes: ViewMkString

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

[use case]

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

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

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

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

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

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

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

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

def toCollection(repr: SeqView[Nothing, Coll]): Seq[Nothing]

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

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

def toIndexedSeq: immutable.IndexedSeq[Nothing]

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

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

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

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

def toIterable: Iterable[Nothing]

Возвращает это итерируемое множество как итерируемое множество.

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

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

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

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

def toIterator: Iterator[Nothing]

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

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

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

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

def toList: List[Nothing]

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

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

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

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

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

[use case]

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

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

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

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

def toParArray: ParArray[T]

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

def toSeq: Seq[Nothing]

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

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

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

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

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

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

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

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

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

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

def toStream: immutable.Stream[Nothing]

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

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

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

def toString(): String

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

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

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

def toTraversable: Traversable[Nothing]

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

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

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

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

def toVector: Vector[Nothing]

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

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

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

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

def transpose[B](implicit asTraversable: (Nothing) ⇒ GenTraversableOnce[B]): Seq[Seq[B]]

Транспонирует эту коллекцию перечислимых коллекций в коллекцию коллекций.

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

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: тип элементов каждой перечислимой коллекции.
asTraversable: неявное преобразование, которое утверждает, что тип элемента этой коллекции является Traversable.
возвращает: двумерная коллекция коллекций, в которой n-я строка является n-м столбцом этой коллекции.

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

lazy val underlying: Coll

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

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

[use case]

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

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

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

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

Definition Classes: SeqViewLike → SeqLike → GenSeqLike

def unzip[A1, A2](implicit asPair: (Nothing) ⇒ (A1, A2)): (EmptyView.Transformed[A1], EmptyView.Transformed[A2])

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

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

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

Definition Classes: TraversableViewLike → GenericTraversableTemplate

def unzip3[A1, A2, A3](implicit asTriple: (Nothing) ⇒ (A1, A2, A3)): (EmptyView.Transformed[A1], EmptyView.Transformed[A2], EmptyView.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[Nothing, SeqView[Nothing, 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[Nothing, SeqView[Nothing, Coll]]

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

final def viewIdString: String

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

def viewIdentifier: String

Attributes: protected[this]
Definition Classes: TraversableViewLike

def viewToString: String

Описание классов: TraversableViewLike

final def wait(): Unit

Описание классов: AnyRef
Аннотации: @throws( ... )

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

Описание классов: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long): Unit

Описание классов: AnyRef
Аннотации: @throws( ... ) @native()

def withFilter(p: (Nothing) ⇒ Boolean): SeqView[Nothing, Coll]

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

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

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

Описание классов: TraversableViewLike → TraversableLike → FilterMonadic

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

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

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

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

Описание классов: IterableViewLike → IterableLike → GenIterableLike

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

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

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

...

def zipWithIndex: Seq[(A, Int)]

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

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

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

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

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

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

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

Неявное

Этот член добавлен неявным преобразованием из EmptyView в MonadOps[Nothing] выполненным методом MonadOps в scala.collection.TraversableOnce.

Затенение

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

(emptyView: MonadOps[Nothing]).filter(p)

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

MonadOps

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

Неявное

Затенение

(emptyView: MonadOps[Nothing]).flatMap(f)

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

MonadOps

def flatten: Iterator[A]

Неявное

Этот член добавлен неявным преобразованием из EmptyView в FlattenOps[A] выполненным методом flattenTraversableOnce в scala.collection.TraversableOnce. Это преобразование будет выполнено только если неявное значение типа (?) ⇒ TraversableOnce[A] находится в области видимости.

Затенение

(emptyView: FlattenOps[A]).flatten

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

FlattenOps

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

Неявное

Затенение

(emptyView: MonadOps[Nothing]).map(f)

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

MonadOps

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

Неявное

Затенение

(emptyView: MonadOps[Nothing]).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/SeqViewLike$EmptyView.html