Объект scala.collection.immutable.Stream.Empty

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

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

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

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

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

Пример:

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)

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

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

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

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

Пример:

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)

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

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

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

Пример:

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)

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

Примечание: /: — это альтернативная синтаксическая конструкция для 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

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

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

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

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

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

Пример:

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)

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

Примечание: :\ — это альтернативная синтаксическая конструкция для 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

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

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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер. Записанный текст состоит из строковых представлений (согласно методу 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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер с использованием разделительной строки. Записанный текст состоит из строковых представлений (согласно методу 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

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

Это более общий вид 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 })

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

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

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

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

Обратите внимание, что выражение 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. Это может привести к лучшей производительности и более предсказуемому поведению относительно побочных эффектов.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Он согласован: для любых не-нулевых экземпляров x и y типа AnyRef, несколько вызовов x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого не-нулевого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Обеспечивает доступ к первому элементу этого Stream за постоянное время. Используя пример fibs из предыдущего раздела:

println(fibs head)
// prints
// 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Указывает, пуста ли Stream.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Библиотека для построения экземпляров типа Traversable[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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))

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

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

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

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

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

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

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))

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

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

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

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

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

FilterMonadic, который позволяет GC головы потока во время обработки

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

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

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

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

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

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