Класс scala.jdk.Accumulator

абстрактный класс Accumulator[@specialized(Double, Int, Long) A, +CC <: (Seq), +C <: Seq[A]] extends Seq[A] with Builder[A, C]

Аккумуляторы — это изменяемые последовательности с двумя отличительными особенностями:

• Аккумулятор можно эффективно добавить к другому

• Существуют специализированные аккумуляторы для Int, Long и Double, которые не упаковывают элементы

Эти две особенности делают аккумуляторы хорошим кандидатом для сбора результатов параллельной Java-потоковой обработки в коллекцию Scala. Метод расширения scala.collection.convert.StreamExtensions.StreamHasToScala.toScala для Java-потоков (доступный путем импорта scala.jdk.StreamConverters._) специализирован для аккумуляторов: они строятся параллельно, части эффективно объединяются.

Создание специализированных аккумуляторов происходит прозрачно. Пользователь, используя объект Accumulator в качестве фабрики, автоматически создаёт IntAccumulator, LongAccumulator, DoubleAccumulator или AnyAccumulator в зависимости от типа элемента.

Примечание: для запуска примера, запустите Scala REPL с scala -Yrepl-class-based чтобы избежать тупиков, см. https://github.com/scala/bug/issues/9076.

scala> import scala.jdk.StreamConverters._
import scala.jdk.StreamConverters._

scala> def isPrime(n: Int): Boolean = !(2 +: (3 to Math.sqrt(n).toInt by 2) exists (n % _ == 0))
isPrime: (n: Int)Boolean

scala> val intAcc = (1 to 10000).asJavaParStream.filter(isPrime).toScala(scala.jdk.Accumulator)
intAcc: scala.jdk.IntAccumulator = IntAccumulator(1, 3, 5, 7, 11, 13, 17, 19, ...

scala> val stringAcc = (1 to 100).asJavaParStream.mapToObj("<>" * _).toScala(Accumulator)
stringAcc: scala.jdk.AnyAccumulator[String] = AnyAccumulator(<>, <><>, <><><>, ...

Есть два способа обработки элементов примитивного аккумулятора без упаковки: специализированные операции аккумулятора или интерфейс Stepper. Наиболее распространенные операции с коллекциями перегружены или переопределены в классах примитивных аккумуляторов, например, IntAccumulator.map или IntAccumulator.exists. Благодаря специализации функций Scala, intAcc.exists(x => testOn(x)) не приводит к упаковке.

Интерфейс scala.collection.Stepper предоставляет итератор-подобные hasStep и nextStep методы и специализирован для Int, Long и Double. Метод intAccumulator.stepper создаёт scala.collection.IntStepper, который возвращает элементы аккумулятора без упаковки.

Аккумуляторы могут содержать более Int.MaxValue элементов. У них есть метод sizeLong, который возвращает размер как Long. Обратите внимание, что некоторые операции, определённые в scala.collection.Seq, реализуются с использованием length, поэтому они не будут работать правильно для больших аккумуляторов.

Класс Accumulator — это базовый класс для совместного использования кода между AnyAccumulator (для ссылочных типов) и ручными специализациями IntAccumulator, LongAccumulator и DoubleAccumulator.

Конкретные методы

Исходный код

def clear(): Unit

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

Исходный код

final override def knownSize: Int

Исходный код

final override def length: Int

Исходный код

final def sizeLong: Long

Размер накопленной коллекции, как Long

Исходный код

final override def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S & EfficientSplit

Наследованные методы

Исходный код@inline

final def ++[B >: A](suffix: IterableOnce[B]): Seq[B]

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

Исходный код@inline

final override def ++:[B >: A](prefix: IterableOnce[B]): Seq[B]

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

Исходный код@inline

final def ++=(xs: IterableOnce[A]): Accumulator[A, CC, C]

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

Исходный код@inline

final def +:[B >: A](elem: B): Seq[B]

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

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

Источник@inline

final def +=(elem: A): Аккумулятор[A, CC, C]

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

Источник@inline

final def :+[B >: A](elem: B): Последовательность[B]

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

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

Источник@inline

final def :++[B >: A](suffix: ИтерируемыйOnce[B]): Последовательность[B]

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

Источник

def addAll(xs: ИтерируемыйOnce[A]): Аккумулятор[A, CC, C]

Добавляет все элементы, производимые ИтерируемымOnce, в эту нарастающую коллекцию.

Источник

def addOne(elem: A): Аккумулятор[A, CC, C]

Добавляет один элемент в эту нарастающую коллекцию.

Источник@inline

final def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

Источник@inline

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

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

Пример:

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

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

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

Исходный код

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

Добавляет все элементы этой коллекции в строку-построитель, используя начальную, конечную и разделительные строки. Текст, который будет записан, начинается со строки start и заканчивается строкой end. Внутри, строковые представления (относительно метода 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 , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Исходный код

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

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

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

Исходный код

override def andThen[C](k: A => C): PartialFunction[Int, C]

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

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

Исходный код

def appended[B >: A](elem: B): Seq[B]

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

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

Пример:

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)

Исходный код

def appendedAll[B >: A](suffix: IterableOnce[B]): Seq[B]

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def apply(i: Int): A

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

Источник

def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: A1 => B1): B1

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

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

if(pf isDefinedAt x) pf(x) else default(x)

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

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерному вычислению apply/isDefinedAt - lift и unlift не вычисляют исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условными действиями

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

Источник

def canEqual(that: Any): Boolean

Источник

override def clone(): Seq[A]

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, A]

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

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

Источник@unspecialized

def compose[A](g: A => Int): A => A

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

Источник@inline

final override def concat[B >: A](suffix: IterableOnce[B]): Seq[B]

Источник

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

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

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

Исходный код

def containsSlice[B >: A](that: Seq[B]): Boolean

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

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

Исходный код

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

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

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

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

Исходный код@deprecatedOverriding("Это должно всегда перенаправлять на 3-аргументную версию этого метода", since = "2.13.4")

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

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

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

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

Исходный код@deprecatedOverriding("Это должно всегда перенаправлять на 3-аргументную версию этого метода", since = "2.13.4")

def copyToArray[B >: A](xs: Array[B]): Int

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean

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

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

Источник

def corresponds[B](that: Seq[B])(p: (A, B) => Boolean): Boolean

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

Источник

def count(p: A => Boolean): Int

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

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

Источник

def diff[B >: A](that: Seq[B]): Seq[A]

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

Источник

def distinct: Seq[A]

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

Source

def distinctBy[B](f: A => B): Seq[A]

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

Source

def drop(n: Int): Seq[A]

Source

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

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

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

Source

def dropWhile(p: A => Boolean): Seq[A]

Source

def elementWise: ElementWiseExtractor[Int, A]

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

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Source

override def empty: Seq[A]

Source

def endsWith[B >: A](that: Iterable[B]): Boolean

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

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

Source

override def equals(o: Any): Boolean

Source

def exists(p: A => Boolean): Boolean

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

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

Source

def filter(pred: A => Boolean): Seq[A]

Source

def filterNot(pred: A => Boolean): Seq[A]

Source

def find(p: A => Boolean): Option[A]

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

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

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

Source

def findLast(p: A => Boolean): Option[A]

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

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

Source

def flatMap[B](f: A => IterableOnce[B]): Seq[B]

Source

def flatten[B](implicit asIterable: A => IterableOnce[B]): Seq[B]

Source

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

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

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

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

Исходный код

def foldLeft[B](z: B)(op: (B, A) => B): B

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

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

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

Исходный код

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

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

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

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

Исходный код

def forall(p: A => Boolean): Boolean

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

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

Исходный код

def foreach[U](f: A => U): Unit

Применить f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи в выводе типов scalac.

Исходный код

protected def fromSpecific(coll: IterableOnce[A]): Seq[A]

Исходный код

def groupBy[K](f: A => K): Map[K, Seq[A]]

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

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

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

Исходный код

def groupMap[K, B](key: A => K)(f: A => B): Map[K, Seq[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором 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)

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

Исходный код

def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B]

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

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

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

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

Исходный код

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

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

Исходный код

override def hashCode(): Int

Исходный код

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B >: A](elem: B): Int

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

Источник

def indexOf[B >: A](elem: B, from: Int): Int

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

Источник@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

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

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

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

Источник

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

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

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

Источник@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

def indexWhere(p: A => Boolean): Int

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

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

Источник

def indexWhere(p: A => Boolean, from: Int): Int

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

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

Источник

def indices: Range

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

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

Источник

def init: Seq[A]

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

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

Источник

def inits: Iterator[Seq[A]]

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

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

Источник

def intersect[B >: A](that: Seq[B]): Seq[A]

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: SeqFactory[Seq]

Источник

def iterator: Iterator[A]

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

Источник

def last: A

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

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

Источник

def lastIndexOf[B >: A](elem: B, end: Int): Int

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

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

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Источник

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

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

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

Источник@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

def lastIndexWhere(p: A => Boolean): Int

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

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

Источник

def lastIndexWhere(p: A => Boolean, end: Int): Int

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

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

Источник

def lastOption: Option[A]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Accumulator[A, CC, C]]

Аналогично 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)

Source

def lengthCompare(that: Iterable[_]): Int

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

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Source

def lengthCompare(len: Int): Int

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

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Source@inline

final def lengthIs: SizeCompareOps

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

Эти операции реализованы в терминах 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

Source

def lift: Int => Option[A]

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

Source

def map[B](f: A => B): Seq[B]

Source

def mapResult[NewTo](f: C => NewTo): Builder[A, NewTo]

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

Source

def max[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A

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

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

Источник

def maxByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Источник

def maxOption[B >: A](implicit ord: Ordering[B]): Option[A]

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

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

Источник

def min[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A

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

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

Источник

def minByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Источник

def minOption[B >: A](implicit ord: Ordering[B]): Option[A]

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

protected def newSpecificBuilder: Builder[A, Seq[A]]

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Источник

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

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

Источник

def padTo[B >: A](len: Int, elem: B): Seq[B]

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

Источник

def partition(p: A => Boolean): (Seq[A], Seq[A])

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

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

Источник

def partitionMap[A1, A2](f: A => Either[A1, A2]): (Seq[A1], Seq[A2])

Применяет функцию 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))

Источник

def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int): Seq[B]

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

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

Источник

def permutations: Iterator[Seq[A]]

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

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

Источник

def prepended[B >: A](elem: B): Seq[B]

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

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

Пример:

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)

Источник

def prependedAll[B >: A](prefix: IterableOnce[B]): Seq[B]

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

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

Источник

def product[B >: A](implicit num: Numeric[B]): B

Произведение элементов этого набора.

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

Источник

def reduce[B >: A](op: (B, B) => B): B

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

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

Источник

def reduceLeft[B >: A](op: (B, A) => B): B

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

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

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

Источник

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

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

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

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

Источник

def reduceOption[B >: A](op: (B, B) => B): Option[B]

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def result(): C

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

Источник

def reverse: Seq[A]

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

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

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

Источник

def reverseIterator: Iterator[A]

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

def sameElements[B >: A](that: IterableOnce[B]): Boolean

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

Источник

def scan[B >: A](z: B)(op: (B, B) => B): Seq[B]

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

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

Источник

def scanLeft[B](z: B)(op: (B, A) => B): Seq[B]

Источник

def scanRight[B](z: B)(op: (A, B) => B): Seq[B]

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

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

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

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

Пример:

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

Источник

def search[B >: A](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

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

Исходный код

def search[B >: A](elem: B)(implicit ord: Ordering[B]): SearchResult

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

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

Исходный код

def segmentLength(p: A => Boolean, from: Int): Int

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

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

Исходный код

final def segmentLength(p: A => Boolean): Int

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

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

Исходный код

final override def size: Int

Исходный код

final override def sizeCompare(that: Iterable[_]): Int

Исходный код

final override def sizeCompare(otherSize: Int): Int

Исходный код

final def sizeHint(coll: IterableOnce[_], delta: Int): Unit

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

Исходный код

def sizeHint(size: Int): Unit

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

Исходный код

final def sizeHintBounded(size: Int, boundingColl: Iterable[_]): Unit

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

Исходный код@inline

final def sizeIs: SizeCompareOps

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

Эти операции реализованы в терминах 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

Исходный код

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

Исходный код

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

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

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

Источник

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

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

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

Источник

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Seq[A]

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Источник

def sortWith(lt: (A, A) => Boolean): Seq[A]

Сортирует этот набор в соответствии с функцией сравнения.

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

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

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

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Источник

def sorted[B >: A](implicit ord: Ordering[B]): Seq[A]

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

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

Источник

def span(p: A => Boolean): (Seq[A], Seq[A])

Источник

override def splitAt(n: Int): (Seq[A], Seq[A])

Источник

def startsWith[B >: A](that: IterableOnce[B], offset: Int): Boolean

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

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

Источник

def sum[B >: A](implicit num: Numeric[B]): B

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

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

Источник

def tail: Seq[A]

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

Источник

def tails: Iterator[Seq[A]]

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

Исходный код

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

Исходный код

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

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

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

Исходный код

def takeWhile(p: A => Boolean): Seq[A]

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

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

Исходный код

override def tapEach[U](f: A => U): Seq[A]

Исходный код

def to[C1](factory: Factory[A, C1]): C1

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

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

Исходный код

def toArray[B >: A : ClassTag]: Array[B]

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

Примечание реализации: НЕ вызывать Array.from из этого метода.

Исходный код@inline

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

def toMap[K, V](implicit ev: A <:< (K, V)): Map[K, V]

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[A]

Исходный код

def transpose[B](implicit asIterable: A => Iterable[B]): Seq[Seq[B]]

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

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

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

Исходный код

def unapply(a: Int): Option[A]

Пытается извлечь B из A в выражении сопоставления с образцом.

Исходный код

def unzip[A1, A2](implicit asPair: A => (A1, A2)): (Seq[A1], Seq[A2])

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

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

Исходный код

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (Seq[A1], Seq[A2], Seq[A3])

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

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

Исходный код@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def update(idx: Int, elem: A): Unit

Заменяет элемент по заданному индексу новым значением.

Исходный код

def updated[B >: A](index: Int, elem: B): Seq[B]

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

Исходный код

override def view: SeqView[A]

Исходный код

def withFilter(p: A => Boolean): WithFilter[A, Seq]

Создаёт нестрогий фильтр этого итерируемого набора.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создаёт новый набор, а второй только ограничивает область действия последующих map, flatMap, foreach, и withFilter операций.

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

Исходный код

def zip[B](that: IterableOnce[B]): Seq[(A, B)]

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

Исходный код

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Seq[(A1, B)]

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

Исходный код

def zipWithIndex: Seq[(A, Int)]