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

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

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

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

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

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

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

Создать новый поток, который содержит все элементы этого потока, за которыми следуют все элементы Traversable 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 и ниже могут использовать перегруз.

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

println(fibs head)
// prints
// 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Более ленивый итератор, чем у LinearSeqLike.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Коллекция типа traversable collection, лежащая в основе этого объекта 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 в соответствии с упорядочением, которое получается из неявно заданного упорядочения с помощью функции преобразования.

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

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

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

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

Сортировка стабильна. То есть элементы, которые равны (как определяется 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 элементов этой Stream, как другую Stream, или всю Stream, если она содержит меньше n элементов.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Транспонирует этот набор итерируемых наборов в набор наборов.

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

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

A 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.