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

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

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

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

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

Создаёт Поток, состоящий из конкатенации заданного Потока и другого Потока.

Создаёт Поток, состоящий из конкатенации заданного Потока и другого Потока.

Псевдоним для concat

Псевдоним для prependedAll

Псевдоним для prepended.

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

Псевдоним для appended

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

Псевдоним для appendedAll

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

Добавляет все элементы этой неизменяемой последовательности в строковый буфер с использованием начальной, конечной и разделительной строк. Текст, который будет записан, начинается со строки start и заканчивается строкой end. Внутри строковые представления (относительно метода toString) всех элементов этой неизменяемой последовательности разделяются строкой sep.

Неопределенные элементы представлены как "_", неопределенная конечная часть — как "<not computed>", а циклы — как "<cycle>".

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

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

Обратите внимание, что вызов isDefinedAt на полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Сильно рекомендуется вызывать applyOrElse вместо isDefinedAt / apply для повышения эффективности.

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

Если тип времени выполнения функции является PartialFunction, то используется другой метод andThen (обратите внимание на его предостережения).

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

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

Пример:

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)

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

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

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

Обратите внимание, что выражение 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]] не выбросит. В последнем примере, поскольку аргумент типа стирается в процессе компиляции, невозможно проверить, соответствуют ли элементы списка запрошенному типу.

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

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

Рекомендуется возвращать имя конкретного типа коллекции, но не подклассы реализации. Например, для ListMap этот метод должен возвращать "ListMap", а не "Map" (супертип) или "Node" (подкласс реализации).

Реализация по умолчанию возвращает "Iterable". Она переопределена для основных типов коллекций "Seq", "IndexedSeq", "LinearSeq", "Buffer", "Set", "Map", "SortedSet", "SortedMap" и "View".

Создаёт копию объекта-получателя.

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

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

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

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

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

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

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

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

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

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Настоятельно рекомендуется вызывать applyOrElse вместо isDefinedAt / apply для повышения эффективности.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пустой итерируемый набор того же типа, что и этот итерируемый набор.

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

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

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

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

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

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

Универсальный метод равенства, определенный в AnyRef.

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Определяет, как преобразовать заданный Iterable[A] в коллекцию типа C.

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

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

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

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

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

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

Разделяет эту итерируемую коллекцию на карту в соответствии с функцией-дискриминатором key. Все значения с одинаковым дискриминатором преобразуются с помощью функции value и затем сводятся к одному значению с помощью функции reduce.

Эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итератор может быть использован только один раз

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без дополнительных расходов на создание и деструктуризацию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Длина (количество элементов) последовательности. size является псевдонимом для length в Seq коллекциях.

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

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

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

Эти операции реализованы с использованием lengthCompare(Int) и позволяют использовать следующие более читаемые выражения:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

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

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

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

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

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

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

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

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

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

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

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

Делегирует вызов addString, который можно переопределить.

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

Делегирует вызов addString, который можно переопределить.

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

Делегирует вызов методу addString, который можно переопределить.

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

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

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

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

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

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

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

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

Применяет функцию f к каждому элементу итерируемого набора и возвращает пару итерируемых наборов: первый содержит значения, возвращённые f, которые были обернуты в scala.util.Left, а второй — значения, обернутые в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

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

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

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

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

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

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

Пример:

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Являются ли элементы этой коллекции одинаковыми (и в том же порядке), что и элементы that?

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

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

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

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

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

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

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

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

Пример:

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

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

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

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

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

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

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

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

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

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

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

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

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

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

Эти операции реализованы в терминах sizeCompare(Int), и позволяют использовать более читаемый код:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает Stepper для элементов этого набора.

Stepper позволяет создавать Java-поток для работы с набором, см. scala.jdk.StreamConverters. Для наборов, содержащих примитивные значения, Stepper можно использовать как итератор, который не упаковывает элементы.

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

Для наборов Int, Short, Byte или Char, возвращается IntStepperДля наборов Double или Float, возвращается DoubleStepperДля наборов Long возвращается LongStepperДля любого другого типа элементов, возвращается AnyStepper

Обратите внимание, что этот метод переопределяется в дочерних классах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, IndexedSeqOps.stepper. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Stepper можно преобразовать только в последовательные потоки.

Суммирует элементы этого набора.

Остальная часть набора без первого элемента.

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

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

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

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

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

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

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

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

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Преобразовать набор в массив.

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

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

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 из A в выражении сопоставления с образцом.

Преобразует необязательную функцию в частичную функцию.

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

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

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

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

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

Представление элементов этой коллекции.

A collection.WithFilter которая позволяет GC головы потока во время обработки

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

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

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