Класс scala.jdk.LongAccumulator

final class LongAccumulator extends Accumulator[Long, AnyAccumulator, LongAccumulator] with SeqOps[Long, AnyAccumulator, LongAccumulator] with Serializable

Специализированный Accumulator, хранящий Long без преобразования к объектам, см. Accumulator.

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

Исходный код

def addOne(a: Long): LongAccumulator

Добавляет элемент в этот LongAccumulator.

Исходный код

def apply(ix: Long): Long

Возвращает ix-й элемент.

Исходный код

def apply(i: Int): Long

Возвращает ix-й элемент, используя Int индекс.

Исходный код

override def clear(): Unit

Исходный код

def collect(pf: PartialFunction[Long, Long]): LongAccumulator

Исходный код

override def count(p: Long => Boolean): Int

Исходный код

def countLong(p: Long => Boolean): Long

Исходный код

def drain(that: LongAccumulator): Unit

Удаляет все элементы из that и добавляет их в этот LongAccumulator.

Исходный код

def efficientStepper[S <: Stepper[_]](implicit shape: StepperShape[Long, S]): S & EfficientSplit

Исходный код

override def empty: LongAccumulator

Исходный код

override def exists(p: Long => Boolean): Boolean

Исходный код

override def filter(pred: Long => Boolean): LongAccumulator

Исходный код

override def filterNot(pred: Long => Boolean): LongAccumulator

Исходный код

def flatMap(f: Long => IterableOnce[Long]): LongAccumulator

Исходный код

override def forall(p: Long => Boolean): Boolean

Исходный код

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

Исходный код

override def iterableFactory: SeqFactory[AnyAccumulator]

Источник

def iterator: Итератор[Длинное целое]

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

Источник

def map(f: Длинное целое => Длинное целое): LongAccumulator

Источник

override def result(): LongAccumulator

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

Источник

override def to[C1](factory: Фабрика[Длинное целое, C1]): C1

Копирует элементы из этой LongAccumulator в указанную коллекцию. Обратите внимание, что целевая коллекция не специализирована. Пример использования: acc.to(Vector)

Источник

def toArray: Массив[Длинное целое]

Копирует элементы из этой LongAccumulator в Array[Long]

Источник

override def toList: Список[Длинное целое]

Копирует элементы из этой LongAccumulator в List

Источник

def update(idx: Длинное целое, elem: Длинное целое): Единица

Источник

def update(idx: Целое число, elem: Длинное целое): Единица

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

Источник@inline

final def ++[B >: Длинное целое](suffix: IterableOnce[B]): AnyAccumulator[B]

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

Источник@inline

final override def ++:[B >: Длинное целое](prefix: IterableOnce[B]): AnyAccumulator[B]

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

Источник@inline

final def ++=(xs: IterableOnce[Длинное целое]): LongAccumulator

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

Источник@inline

final def +:[B >: Длинное целое](elem: B): AnyAccumulator[B]

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

Источник@inline

final def +=(elem: Длинное целое): LongAccumulator

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

Источник@inline

final def :+[B >: Длинное целое](elem: B): AnyAccumulator[B]

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

Источник@inline

final def :++[B >: Длинное целое](suffix: IterableOnce[B]): AnyAccumulator[B]

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

Источник

def addAll(xs: IterableOnce[Длинное целое]): LongAccumulator

Добавляет все элементы, полученные из IterableOnce, в эту коллекцию.

Источник@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: Строка): 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[Long, C]): PartialFunction[Int, C]

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

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

Исходный код

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

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

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

Исходный код

def appended[B >: Long](elem: B): AnyAccumulator[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 >: Long](suffix: IterableOnce[B]): AnyAccumulator[B]

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

Исходный код

def applyOrElse[A1 <: Int, B1 >: Long](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(): LongAccumulator

Исходный код

def collect[B](pf: PartialFunction[Long, B]): AnyAccumulator[B]

Исходный код

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

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

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

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

Источник

def combinations(n: Int): Iterator[LongAccumulator]

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

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

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

Источник

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

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

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

Источник@unspecialized

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

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

Источник@inline

final override def concat[B >: Long](suffix: IterableOnce[B]): AnyAccumulator[B]

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник

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

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

Источник

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

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

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

Источник

def diff[B >: Long](that: Seq[B]): LongAccumulator

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

Источник

def distinct: LongAccumulator

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

Источник

def distinctBy[B](f: Long => B): LongAccumulator

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

Источник

def drop(n: Int): LongAccumulator

Источник

def dropRight(n: Int): LongAccumulator

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

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

Источник

def dropWhile(p: Long => Boolean): LongAccumulator

Источник

def elementWise: ElementWiseExtractor[Int, Long]

Возвращает объект извлекателя с методом 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
}

Источник

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

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

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

Источник

override def equals(o: Any): Boolean

Источник

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

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

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

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

Источник

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

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

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

Источник

def flatMap[B](f: Long => IterableOnce[B]): AnyAccumulator[B]

Источник

def flatten[B](implicit asIterable: Long => IterableOnce[B]): AnyAccumulator[B]

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def groupBy[K](f: Long => K): Map[K, LongAccumulator]

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

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

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

Источник

def groupMap[K, B](key: Long => K)(f: Long => B): Map[K, AnyAccumulator[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: Long => K)(f: Long => 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[LongAccumulator]

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

Источник

override def hashCode(): Int

Источник

def head: Long

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

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

Источник

def headOption: Option[Long]

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

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

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

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

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

Источник

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: LongAccumulator

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

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

Источник

def inits: Iterator[LongAccumulator]

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

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

Источник

def intersect[B >: Long](that: Seq[B]): LongAccumulator

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

final override def knownSize: Int

Источник

def last: Long

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

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

Источник

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

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

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

Исходный код@deprecatedOverriding("Замените lastIndexOfSlice(that, end) - lastIndexOfSlice(that) вызывает lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Замените lastIndexWhere(p, end) - lastIndexWhere(p) вызывает lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код

def lastOption: Option[Long]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[Long, B, LongAccumulator]

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

Источник

final override def length: Int

Источник

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

Источник

def lengthCompare(len: Int): Int

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

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

Источник@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

Источник

def lift: Int => Option[Long]

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

Источник

def map[B](f: Long => B): AnyAccumulator[B]

Источник

def mapResult[NewTo](f: LongAccumulator => NewTo): Builder[Long, NewTo]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@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, который можно переопределить.

Исходный код@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Исходный код

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

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

Исходный код

def padTo[B >: Long](len: Int, elem: B): AnyAccumulator[B]

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

Источник

def partition(p: Long => Boolean): (LongAccumulator, LongAccumulator)

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

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

Источник

def partitionMap[A1, A2](f: Long => Either[A1, A2]): (AnyAccumulator[A1], AnyAccumulator[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 >: Long](from: Int, other: IterableOnce[B], replaced: Int): AnyAccumulator[B]

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

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

Источник

def permutations: Iterator[LongAccumulator]

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

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

Источник

def prepended[B >: Long](elem: B): AnyAccumulator[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 >: Long](prefix: IterableOnce[B]): AnyAccumulator[B]

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def reverse: LongAccumulator

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

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

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

Источник

def reverseIterator: Iterator[Long]

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

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

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

Источник

protected def reversed: Iterable[Long]

Источник

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

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

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

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

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

Источник

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

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

Источник

def scan[B >: Long](z: B)(op: (B, B) => B): AnyAccumulator[B]

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

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

Источник

def scanLeft[B](z: B)(op: (B, Long) => B): AnyAccumulator[B]

Source

def scanRight[B](z: B)(op: (Long, B) => B): AnyAccumulator[B]

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

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

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

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

Пример:

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final override def size: Int

Source

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

Source

final override def sizeCompare(otherSize: Int): Int

Source

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

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

Source

def sizeHint(size: Int): Unit

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

Source

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

Источник

final def sizeLong: Long

Размер накопленного набора в качестве Long

Источник

def slice(from: Int, until: Int): LongAccumulator

Источник

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

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

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

Источник

def sliding(size: Int): Iterator[LongAccumulator]

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

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

Источник

def sortBy[B](f: Long => B)(implicit ord: Ordering[B]): LongAccumulator

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

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

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

Сортировка стабильна. То есть, элементы, которые равны (как определено 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: (Long, Long) => Boolean): LongAccumulator

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

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

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

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

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

Источник

def sorted[B >: Long](implicit ord: Ordering[B]): LongAccumulator

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

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

Источник

def span(p: Long => Boolean): (LongAccumulator, LongAccumulator)

Источник

override def splitAt(n: Int): (LongAccumulator, LongAccumulator)

Source

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

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

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

Source

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

Source

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

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

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

Source

def tail: LongAccumulator

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

Source

def tails: Iterator[LongAccumulator]

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

Source

def take(n: Int): LongAccumulator

Source

def takeRight(n: Int): LongAccumulator

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

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

Source

def takeWhile(p: Long => Boolean): LongAccumulator

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

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

Source

override def tapEach[U](f: Long => U): LongAccumulator

Source

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

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

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[Long]

Source

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

Source

def toSeq: Seq[Long]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[Long]

Source

def transpose[B](implicit asIterable: Long => Iterable[B]): AnyAccumulator[AnyAccumulator[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))

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

Source

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

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

Source

def unzip[A1, A2](implicit asPair: Long => (A1, A2)): (AnyAccumulator[A1], AnyAccumulator[A2])

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

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

Source

def unzip3[A1, A2, A3](implicit asTriple: Long => (A1, A2, A3)): (AnyAccumulator[A1], AnyAccumulator[A2], AnyAccumulator[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))

Source

def updated[B >: Long](index: Int, elem: B): AnyAccumulator[B]

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

Source

override def view: SeqView[Long]

Source

def withFilter(p: Long => Boolean): WithFilter[Long, AnyAccumulator]

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

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

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

Source

def zip[B](that: IterableOnce[B]): AnyAccumulator[(Long, B)]

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

Source

def zipAll[A1 >: Long, B](that: Iterable[B], thisElem: A1, thatElem: B): AnyAccumulator[(A1, B)]

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

Исходный код

def zipWithIndex: AnyAccumulator[(Long, Int)]