Класс scala.collection.immutable.Stream

Компаньон объект Stream

запечатанный абстрактный класс Stream[+A] extends AbstractSeq[A] с LinearSeq[A] с GenericTraversableTemplate[A, Stream] с LinearSeqOptimized[A, Stream[A]] с Serializable

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

import scala.math.BigInt
object Main extends App {

  lazy val fibs: Stream[BigInt] = BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }

  fibs take 5 foreach println
}

// prints
//
// 0
// 1
// 1
// 2
// 3

Класс Stream также использует кэширование, таким образом, ранее вычисленные значения преобразуются из Stream элементов в конкретные значения типа A. Чтобы проиллюстрировать, мы изменим тело значения fibs выше и возьмём ещё несколько значений:

import scala.math.BigInt
object Main extends App {

  lazy val fibs: Stream[BigInt] = BigInt(0) #:: BigInt(1) #:: fibs.zip(
    fibs.tail).map(n => {
      println("Adding %d and %d".format(n._1, n._2))
      n._1 + n._2
    })

  fibs take 5 foreach println
  fibs take 6 foreach println
}

// prints
//
// 0
// 1
// Adding 0 and 1
// 1
// Adding 1 and 1
// 2
// Adding 1 and 2
// 3

// And then prints
//
// 0
// 1
// 1
// 2
// 3
// Adding 2 and 3
// 5

Существует ряд тонких моментов в приведённом примере.

Определение fibs является val а не методом. Кэширование Stream требует наличия места для хранения информации, а val позволяет это сделать.
Хотя Stream фактически изменяется во время доступа, это не изменяет концепции его неизменяемости. После кэширования значения не меняются, а значения, которые ещё не были кэшированы, всё ещё «существуют», просто они ещё не были реализованы.
Следует быть осторожным с кэшированием; вы очень быстро можете израсходовать большой объём памяти, если не будете внимательны. Причина в том, что кэширование Stream создаёт структуру, очень похожую на scala.collection.immutable.List. Пока что-то держит заголовок, заголовок держит хвост, и так далее рекурсивно. Если же ничего не держит заголовок (например, мы использовали def для определения Stream) то после того, как он больше не используется непосредственно, он исчезает.
Обратите внимание, что некоторые операции, включая drop, dropWhile, flatMap или collect могут обработать большое количество промежуточных элементов перед возвратом. Они обязательно удерживают заголовок, поскольку являются методами на Stream, а поток хранит свой собственный заголовок. Для вычислений такого рода, где кэширование нежелательно, используйте Iterator когда это возможно.

// For example, let's build the natural numbers and do some silly iteration
// over them.

// We'll start with a silly iteration
def loop(s: String, i: Int, iter: Iterator[Int]): Unit = {
  // Stop after 200,000
  if (i < 200001) {
    if (i % 50000 == 0) println(s + i)
    loop(s, iter.next, iter)
  }
}

// Our first Stream definition will be a val definition
val stream1: Stream[Int] = {
  def loop(v: Int): Stream[Int] = v #:: loop(v + 1)
  loop(0)
}

// Because stream1 is a val, everything that the iterator produces is held
// by virtue of the fact that the head of the Stream is held in stream1
val it1 = stream1.iterator
loop("Iterator1: ", it1.next, it1)

// We can redefine this Stream such that all we have is the Iterator left
// and allow the Stream to be garbage collected as required.  Using a def
// to provide the Stream ensures that no val is holding onto the head as
// is the case with stream1
def stream2: Stream[Int] = {
  def loop(v: Int): Stream[Int] = v #:: loop(v + 1)
  loop(0)
}
val it2 = stream2.iterator
loop("Iterator2: ", it2.next, it2)

// And, of course, we don't actually need a Stream at all for such a simple
// problem.  There's no reason to use a Stream if you don't actually need
// one.
val it3 = new Iterator[Int] {
  var i = -1
  def hasNext = true
  def next(): Int = { i += 1; i }
}
loop("Iterator3: ", it3.next, it3)

Интересно, что tail вообще работает. В определении fibs у нас есть начальное значение (0, 1, Stream(...)), поэтому tail детерминировано. Если мы определили fibs так, что только 0 были известны конкретно, то акт определения tail потребовал бы вычисления tail, что вызвало бы бесконечную рекурсию и переполнение стека. Если мы определяем определение, где хвост изначально не вычислим, то у нас будет бесконечная рекурсия:

// The first time we try to access the tail we're going to need more
// information which will require us to recurse, which will require us to
// recurse, which...
lazy val sov: Stream[Vector[Int]] = Vector(0) #:: sov.zip(sov.tail).map { n => n._1 ++ n._2 }

Определение fibs выше создаёт большее количество объектов, чем необходимо, в зависимости от того, как вы можете это реализовать. Следующая реализация обеспечивает более «эффективную» реализацию, поскольку она имеет более прямой путь к самим числам:

lazy val fib: Stream[Int] = {
  def loop(h: Int, n: Int): Stream[Int] = h #:: loop(n, h + n)
  loop(1, 1)
}

Обратите внимание, что mkString принудительно вызывает вычисление Stream, но addString нет. В обоих случаях, Stream который является или заканчивается циклом (например, lazy val s: Stream[Int] = 0 #:: s) преобразует дополнительные обходы цикла в .... Кроме того, addString отобразит некэшированный хвост как ?.

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

Self Type: Stream[A]
Источник: Stream.scala
С: 2.8
См. также: обзор библиотеки коллекций Scala раздел о Streams для получения дополнительной информации.

Линейные надтипы

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

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

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

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

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

тип Self = Stream[A]

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

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

Абстрактные члены

абстрактный def tailDefined: Boolean

Определён ли хвост этого потока?

Атрибуты: protected

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

final def !=(arg0: Any): Boolean

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

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

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

final def ##(): Int

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

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

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

def #::[B >: A](hd: B): Stream[B]

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

Неявный: Этот член добавлен благодаря неявной конвертации из Stream[A] в ConsWrapper[A], выполненной методом consWrapper в scala.collection.immutable.Stream.
Классы-определения: ConsWrapper

def #:::[B >: A](prefix: Stream[B]): Stream[B]

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

Неявный: Этот член добавлен благодаря неявной конвертации из Stream[A] в ConsWrapper[A], выполненной методом consWrapper в scala.collection.immutable.Stream.
Классы-определения: ConsWrapper

def +(other: String): String

Неявный: Этот член добавлен благодаря неявной конвертации из Stream[A] в any2stringadd[Stream[A]] , выполненной методом any2stringadd в scala.Predef.
Классы-определения: any2stringadd

def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That

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

B: Тип элемента возвращаемого набора.That
That: класс возвращаемого набора. В случае возможности, That – это тот же класс, что и текущий класс коллекции Repr, но это зависит от того, допускается ли элемент типа B для этого класса, что означает, что найдена неявная сущность типа CanBuildFrom[Repr, B, That].
that: Передаваемый scala.collection.GenTraversableOnce для конкатенации с этим Stream.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента B.
возвращает: Новый набор, содержащий результат конкатенации this с that.

Классы-определения: Stream → TraversableLike → GenTraversableLike
Примечание: Непосредственно ясно, почему это работает. Мы знаем, что если целевой тип scala.collection.mutable.Builder That является либо Stream, или одним из его супертипов, или неопределенным, то StreamBuilder будет выбран для неявной сущности. Мы признаем этот факт и оптимизируем, чтобы получить больше ленивости.
,
Этот метод не вызывает полную реализацию Stream, но следует отметить, что использование оператора ++ из другого типа коллекции может привести к бесконечной реализации Stream. Например, со ссылкой на определение fibs в преамбуле, следующее никогда не вернется: List(BigInt(12)) ++ fibs.

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That

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

Отличается от ++ тем, что правый операнд определяет тип возвращаемой коллекции, а не левый. Мемоника: двоеточие стоит на стороне нового типа коллекции.

Пример:

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

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

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

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

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

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

Definition Classes: TraversableLike

def ++:[B](that: TraversableOnce[B]): Stream[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: перебираемый для добавления.
returns: новый поток, содержащий все элементы этого потока, за которыми следуют все элементы that.

Definition Classes: TraversableLike

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

[use case]

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

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

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

Пример:

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

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

scala> println(x)
List(1)

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

Definition Classes: Stream → SeqLike → GenSeqLike

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

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

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

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

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

Примеры:

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

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

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

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Пример:

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

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

scala> println(a)
List(1)

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

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

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

Примеры:

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

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

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

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

B

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

z

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

op

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

returns

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

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

где x₁, ..., x_n являются элементами этого итерируемого объекта или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

final def ==(arg0: Any): Boolean

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

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

Definition Classes: AnyRef → Any

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

Записывает все определенные элементы этого итерируемого объекта в заданный буфер строк. Текст, который будет записан, начинается со строки start и заканчивается строкой end. Внутри строковые представления определенных элементов (согласно методу toString()) разделены строкой sep. Метод не будет принудительно вычислять неопределенные элементы. Оставшаяся часть таких элементов будет представлена маркером "?". Циклический поток представлен маркером "..." в точке повторения цикла.

b: Объект collection.mutable.StringBuilder, в который необходимо добавить строковые элементы.
start: Префикс результирующей строки (например, "Stream(")
sep: Разделитель между элементами результирующей строки (например, ",")
end: Окончание результирующей строки (например, ")")
returns: Исходный объект collection.mutable.StringBuilder, содержащий результирующую строку.

Definition Classes: Stream → TraversableOnce

def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

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

Definition Classes: TraversableOnce

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

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

Пример:

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

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

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

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

Definition Classes: TraversableOnce

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

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

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

Definition Classes: PartialFunction → Function1

def append[B >: A](rest: ⇒ TraversableOnce[B]): Stream[B]

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

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

def apply(n: Int): A

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

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

Definition Classes: LinearSeqOptimized → SeqLike → GenSeqLike
Exceptions thrown: IndexOutOfBoundsException, если idx не удовлетворяет 0 <= idx < length.

def applyOrElse[A1 <: Int, B1 >: A](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: функция обратного вызова
returns: результат применения этой функции или функции обратного вызова.

Definition Classes: PartialFunction
Since: 2.10

final def asInstanceOf[T0]: T0

Преобразует объект-приемник к типу T0.

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

returns: объект-приемник.

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

def canEqual(that: Any): Boolean

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

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

Definition Classes: IterableLike → Equals

def clone(): AnyRef

Создает копию объекта-приемника.

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

returns: копию объекта-приемника.

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

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

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

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

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

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

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

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

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

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

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

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

def combinations(n: Int): Iterator[Stream[A]]

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

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

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

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

def companion: GenericCompanion[Stream]

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

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

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

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

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

Определяющие классы: Function1
Аннотации: @unspecialized()

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

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

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

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

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

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

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

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

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

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

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

[use case]

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

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

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

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce

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

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

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

Definition Classes: LinearSeqLike → SeqLike → GenSeqLike
Annotations: @tailrec()

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def distinct: Stream[A]

Создаёт новый поток из этого потока, в котором удалены все дубликаты (определяются ==). Среди элементов-дубликатов сохраняется только первый в результирующем Stream.

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

Definition Classes: Stream → SeqLike → GenSeqLike

final def drop(n: Int): Stream[A]

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

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

Definition Classes: Stream → LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike
Annotations: @tailrec()

def dropRight(n: Int): Stream[A]

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

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

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

Definition Classes: Stream → LinearSeqOptimized → IterableLike

def dropWhile(p: (A) ⇒ Boolean): Stream[A]

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

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

Definition Classes: Stream → TraversableLike → GenTraversableLike
Note: Этот метод реализует весь Stream за пределами истинности предиката p.

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

def ensuring(cond: (Stream[A]) ⇒ Boolean): Stream[A]

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

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

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

def ensuring(cond: Boolean): Stream[A]

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

final def eq(arg0: AnyRef): Boolean

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

Метод eq реализует отношение эквивалентности на не-null экземплярах 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 в противном случае

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

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

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

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

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

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

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

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

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

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

def filterNot(p: (A) ⇒ Boolean): Stream[A]

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

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

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

def finalize(): Unit

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

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

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

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

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

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

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

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

final def flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That

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

B: Тип элементов возвращаемого набора That.
That: Класс возвращаемого набора. По возможности, That — это тот же класс, что и текущий класс набора Repr, но это зависит от того, допускается ли тип элемента B для этого класса, что означает, что найдена неявная инстанция типа CanBuildFrom[Repr, B, That].
f: функция, применяемая к каждому элементу.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента B.
returns: f(a₀) ::: ... ::: f(a_n) если этот поток [a₀, ..., a_n].

Definition Classes: Stream → TraversableLike → GenTraversableLike → FilterMonadic

def flatten[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Stream[B]

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

B: Тип элементов полученного Stream.
asTraversable: неявное преобразование, утверждающее, что тип элемента этого потока является GenTraversable.
returns: Новый Stream типа B сплюснутых элементов this Stream.

Definition Classes: Stream → GenericTraversableTemplate

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

Специализация Stream для foldLeft, которая позволяет GC собирать по ходу.

B: Тип накапливаемого значения.
z: Начальное значение, подаваемое в функцию op.
op: Операция, выполняемая над последовательными элементами Stream.
returns: Накопленное значение от последовательных применений op.

Definition Classes: Stream → LinearSeqOptimized → TraversableOnce → GenTraversableOnce
Annotations: @tailrec()

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

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

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

B

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

z

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

op

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

returns

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

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

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

Definition Classes: LinearSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce

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

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

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

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

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

def force: Stream[A]

Вынуждает вычисление всего потока и возвращает его.

returns: Полностью реализованный Stream.

Note: Часто мы используем Stream для представления бесконечного множества или ряда. Если это относится к вашему конкретному Stream , то эта функция никогда не вернется и, вероятно, завершит работу виртуальной машины с исключением OutOfMemory. Однако эта функция не будет зависать на конечном цикле.

final def foreach[U](f: (A) ⇒ U): Unit

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

U: параметр типа, описывающий результат функции f. Этот результат всегда будет игнорироваться. Как правило, U является Unit, но это необязательно.
f: Обработка, которая должна быть применена к каждому элементу.

Definition Classes: Stream → LinearSeqOptimized → IterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
Annotations: @tailrec()
Note: Переопределено здесь как final, чтобы запустить оптимизацию хвостовой рекурсии, которая заменяет 'this' на 'tail' на каждой итерации. Это абсолютно необходимо для того, чтобы GC мог собирать подлежащий поток по мере потребления элементов.
,
Эта функция заставит реализовать весь поток, если только f не выбросит исключение.

def formatted(fmtstr: String): String

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

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

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

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

Definition Classes: GenericTraversableTemplate

final def getClass(): Class[_]

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

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

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

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

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

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

K

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

f

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

returns

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def grouped(size: Int): Iterator[Stream[A]]

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

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

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

def hasDefiniteSize: Boolean

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

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

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

Definition Classes: Stream → TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

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

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

Definition Classes: LinearSeqLike → GenSeqLike → AnyRef → Any

def head: A

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

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

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

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

def headOption: Option[A]

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

[use case]

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

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

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

Definition Classes: GenSeqLike

def indexOf(elem: A): Int

[use case]

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

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

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

Definition Classes: GenSeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: LinearSeqOptimized → SeqLike → GenSeqLike

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

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

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

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

Definition Classes: GenSeqLike

def indices: Range

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

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

Definition Classes: SeqLike

def init: Stream[A]

Поток без его последнего элемента.

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

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

def inits: Iterator[Stream[A]]

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

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

Definition Classes: TraversableLike

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def isDefinedAt(x: Int): Boolean

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

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

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

Definition Classes: LinearSeqOptimized → GenSeqLike

def isEmpty: Boolean

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

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes: Any

final def isTraversableAgain: Boolean

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

возвращает: true

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

def iterator: Iterator[A]

Более ленивый Iterator, чем LinearSeqLike's.

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

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

def last: A

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

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

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

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

[use case]

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

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

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

def lastIndexOf(elem: A): Int

[use case]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def lastOption: Option[A]

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

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

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

def length: Int

Возвращает длину этого Stream.

returns: Длина этого Stream.

Definition Classes: Stream → LinearSeqOptimized → SeqLike → GenSeqLike
Note: Для вычисления длины Stream, она должна быть полностью реализована, что может привести к полному вычислению бесконечной последовательности, предполагая, что это то, что представляет ваш Stream.

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: LinearSeqOptimized → SeqLike

def lift: (Int) ⇒ Option[A]

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

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

Definition Classes: PartialFunction
See also: Function.unlift

final def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That

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

B: Тип элемента возвращаемого набора That.
That: класс возвращаемого набора. По возможности, That имеет тот же класс, что и текущий класс набора Repr, но это зависит от того, допустим ли тип элемента B для этого класса, что означает, что найдено неявное значение типа CanBuildFrom[Repr, B, That].
f: функция, применяемая к каждому элементу.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента B.
returns: f(a₀), ..., f(a_n) если эта последовательность a₀, ..., a_n.

Definition Classes: Stream → 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: Функция измерения.
возвращает: первый элемент этого потока с наименьшим значением, измеренным функцией f.

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

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

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

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

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

def mkString: String

Отображает все элементы этого потока в строке.

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

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

def mkString(sep: String): String

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

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

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

final def ne(arg0: AnyRef): Boolean

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

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

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

def newBuilder: Builder[A, Stream[A]]

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

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

def nonEmpty: Boolean

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

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

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

final def notify(): Unit

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

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

final def notifyAll(): Unit

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

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

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

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

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

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

def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That

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

B: Тип значения для дополнения.
That: Тип, содержащийся в результирующем Stream.
len: Количество элементов для добавления в Stream.
elem: Значение типа B для использования при дополнении.
bf: явное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента B.
returns: Новая Stream , представляющая коллекцию с добавленными значениями до конца. Если ваша Stream представляет бесконечную последовательность, этот метод не вернет результат.

Definition Classes: Stream → SeqLike → GenSeqLike

def par: ParSeq[A]

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

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

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

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

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

Definition Classes: Parallelizable

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

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

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

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

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

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

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

Definition Classes: Stream → TraversableLike → GenTraversableLike

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

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def permutations: Iterator[Stream[A]]

Перебирает различные перестановки.

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

Definition Classes: SeqLike

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

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

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

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

Definition Classes: GenSeqLike

def print(sep: String): Unit

Выводит элементы этого потока по одному, разделенные sep.

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

def print(): Unit

def product: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

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

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

Специализация reduceLeft для потоков, которая позволяет сборщику мусора собирать по ходу работы.

B: Тип накапливаемого значения.
f: Операция для выполнения над последующими элементами Stream.
returns: Накопленное значение из последовательных применений f.

Definition Classes: Stream → LinearSeqOptimized → TraversableOnce

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

B

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

op

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

returns

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

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

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

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

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

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def repr: Stream[A]

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: Stream[A]

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

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

Definition Classes: Stream → SeqLike → GenSeqLike
Примечание: Эта функция должна реализовать всю Stream для выполнения этой операции, поэтому если ваш Stream представляет собой бесконечную последовательность, то эта функция никогда не вернётся.

def reverseIterator: Iterator[A]

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reversed: scala.List[A]

Attributes: protected[this]
Definition Classes: TraversableOnce

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

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

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

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

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

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

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

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

[use case]

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

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

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

Definition Classes: LinearSeqOptimized → IterableLike → GenIterableLike

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

Создаёт новый поток, который содержит все промежуточные результаты применения оператора слева направо. scanLeft аналогично foldLeft.

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

Definition Classes: Stream → TraversableLike → GenTraversableLike
Note: Это работает, потому что целевой тип scala.collection.mutable.Builder That является Stream.

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

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

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

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

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

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

Definition Classes: TraversableLike → GenTraversableLike
Annotations: @migration
Migration: (Изменено в версии 2.9.0) Поведение scanRight изменилось. Предыдущее поведение можно воспроизвести с помощью scanRight.reverse.

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

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

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

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

Definition Classes: LinearSeqOptimized → SeqLike → GenSeqLike

def seq: LinearSeq[A]

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

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

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

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

def size: Int

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

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

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

Definition Classes: SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

def sizeHintIfCheap: Int

Размер этой коллекции или итератора, если он может быть вычислен недорого

returns: количество элементов в этой коллекции или итераторе, или -1, если размер не может быть определен недорого

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(from: Int, until: Int): Stream[A]

Подпоследовательность, начинающаяся с индекса from и продолжающаяся до (но не включая) индекс until. Возвращает Stream, который вычисляется лениво.

from: Индекс первого элемента возвращаемой подпоследовательности
until: Индекс элемента, следующего за возвращаемой подпоследовательностью
returns: Новая строка, содержащая запрашиваемые элементы с start по end.

Definition Classes: Stream → LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

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

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

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

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

def sliding(size: Int): Iterator[Stream[A]]

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

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

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

def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): Stream[A]

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

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

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

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

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

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

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

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

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

Definition Classes: LinearSeqOptimized → TraversableLike → GenTraversableLike

def splitAt(n: Int): (Stream[A], Stream[A])

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

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

Definition Classes: Stream → 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, примененный к этому потоку. По умолчанию строковый префикс - это простое имя класса коллекции stream.

Definition Classes: Stream → 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: Stream[A]

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

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

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

def tails: Iterator[Stream[A]]

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

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

Definition Classes: LinearSeqOptimized → TraversableLike

def take(n: Int): Stream[A]

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

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

n: количество элементов для взятия.
returns: первые n элементов этого потока.

Definition Classes: Stream → LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): Stream[A]

Возвращает правые n элементов этого итерируемого объекта.

n: количество элементов для взятия
returns: Последние n элементов этого потока.

Definition Classes: Stream → IterableLike
Примечание: Будьте внимательны. Если поток представляет бесконечную последовательность, эта функция не вернёт результат. Получение последних элементов бесконечной последовательности займёт бесконечное время.

def takeWhile(p: (A) ⇒ Boolean): Stream[A]

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

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

Definition Classes: Stream → LinearSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

def thisCollection: collection.LinearSeq[A]

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

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

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

[use case]

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toCollection(repr: Stream[A]): collection.LinearSeq[A]

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

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

def toIndexedSeq: IndexedSeq[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toIterable: collection.Iterable[A]

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

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

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

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

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

def toIterator: Iterator[A]

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

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

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

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

def toList: scala.List[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toParArray: ParArray[T]

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

def toSeq: Seq[A]

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

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

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

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

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

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

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

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

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

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

def toStream: Stream[A]

Преобразует этот поток в поток.

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

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

def toString(): String

Преобразует этот поток в строку.

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

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

def toTraversable: collection.Traversable[A]

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

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

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

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

def toVector: scala.Vector[A]

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

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

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

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

def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Stream[Stream[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 если все коллекции в этой коллекции не имеют одинаковый размер.

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

[use case]

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

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

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

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

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

def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Stream[A1], Stream[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: GenericTraversableTemplate

def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Stream[A1], Stream[A2], Stream[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: GenericTraversableTemplate

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

[use case]

Копия этого потока с одним заменённым элементом.

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

Definition Classes: SeqLike → GenSeqLike

def view: StreamView[A, Stream[A]]

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

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

Definition Classes: Stream → SeqLike → IterableLike → TraversableLike

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

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

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

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

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

Definition Classes: SeqLike → IterableLike → TraversableLike

final def wait(): Unit

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

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

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

final def wait(arg0: Long): Unit

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

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

A FilterMonadic which allows GC of the head of stream during processing

p: the predicate used to test elements.
returns: an object of class WithFilter, which supports map, flatMap, foreach, and withFilter operations. All these operations apply to those elements of this stream which satisfy the predicate p.

Definition Classes: Stream → TraversableLike → FilterMonadic
Annotations: @noinline()

final def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Stream[A], (A1, B), That]): That

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

Если один из двух потоков длиннее другого, его оставшиеся элементы игнорируются.

Тип возвращаемого значения этой функции может быть не очевиден. Ленивый аспект возвращаемого значения отличается от partition. В partition мы получаем scala.Tuple2 из двух ленивых Stream , а здесь мы получаем один ленивый Stream из scala.Tuple2, где тип сигнатуры scala.Tuple2 такой: (A1, B).

A1: Тип первого параметра кортежа zip
B: Тип второго параметра кортежа zip
That: Тип возвращаемого Stream.
that: Итерируемый объект, предоставляющий вторую половину каждой пары результатов
bf: явное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента (A1, B).
returns: Stream({a₀,b₀}, ..., {a_min(m,n),b_min(m,n))} при вызове Stream(a₀, ..., a_m) zip Stream(b₀, ..., b_n).

Definition Classes: Stream → IterableLike → GenIterableLike

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Stream[(A, B)]

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Stream[A], (A1, Int), That]): That

Объединяет этот итерируемый объект с его индексами. s.zipWithIndex эквивалентно s zip s.indices.

Этот метод очень похож на zip тем, что он возвращает один ленивый Stream из scala.Tuple2.

A1: Тип первого элемента scala.Tuple2 в результирующем потоке.
That: Тип результирующего Stream.
bf: явное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента (A1, Int).
returns: Stream({a₀,0}, ..., {a_n,n)}

Definition Classes: Stream → IterableLike → GenIterableLike

def →[B](y: B): (Stream[A], B)

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

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

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

Неявный

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

Затенение

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

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

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

MonadOps

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

Неявный

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

Затенение

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

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

MonadOps

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

Неявный

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

Затенение

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

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

MonadOps

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

Неявный

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

Затенение

(stream: MonadOps[A]).withFilter(p)

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

MonadOps

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/immutable/Stream.html