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

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

Эквивалентно 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, которая позволяет сборщику мусора собирать по ходу.

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

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

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

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

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

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

Возвращает строку, отформатированную в соответствии с заданной строкой format. Формат строк аналогичен String.format (@см. 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Аналогично 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), появляются в отсортированной последовательности в том же порядке, что и в исходной.

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

Сортировка устойчива. То есть элементы, которые равны (как определено 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 к своим элементам немедленно, в то время как ленивые наборы, такие как Views и 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 механизм, который позволяет выполнять сборку мусора для начала потока во время обработки

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

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

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