Класс scala.jdk.IntAccumulator

final class IntAccumulator extends Accumulator[Целое число, AnyAccumulator, IntAccumulator] with SeqOps[Целое число, AnyAccumulator, IntAccumulator] with Serializable

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

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

Исходный код

def addOne(a: Целое число): IntAccumulator

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

Исходный код

def apply(ix: Длинное целое число): Целое число

Возвращает элемент с ix-ым индексом.

Исходный код

def apply(i: Целое число): Целое число

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

Исходный код

override def clear(): Unit

Исходный код

def collect(pf: PartialFunction[Целое число, Целое число]): IntAccumulator

Исходный код

override def count(p: Целое число => Булево): Целое число

Исходный код

def countLong(p: Целое число => Булево): Длинное целое число

Исходный код

def drain(that: IntAccumulator): Unit

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

Исходный код

def efficientStepper[S <: Stepper[_]](implicit shape: StepperShape[Целое число, S]): S & EfficientSplit

Исходный код

override def empty: IntAccumulator

Исходный код

override def exists(p: Целое число => Булево): Булево

Исходный код

override def filter(pred: Целое число => Булево): IntAccumulator

Исходный код

override def filterNot(pred: Целое число => Булево): IntAccumulator

Исходный код

def flatMap(f: Целое число => IterableOnce[Целое число]): IntAccumulator

Исходный код

override def forall(p: Целое число => Булево): Булево

Исходный код

override def foreach[U](f: Целое число => U): Unit

Исходный код

override def iterableFactory: SeqFactory[AnyAccumulator]

Источник

def iterator: Итератор[Целое]

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

Источник

def map(f: Целое => Целое): IntAccumulator

Источник

override def result(): IntAccumulator

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

Источник

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

Копирует элементы из этого накопителя в указанную коллекцию. Целевая коллекция не специализирована. Пример использования: acc.to(Vector)

Источник

def toArray: Массив[Целое]

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

Источник

override def toList: Список[Целое]

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

Источник

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

Источник

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

Наследуемые методы

Источник@inline

final def ++[B >: Целое](suffix: ИтерируемаяОднажды[B]): AnyAccumulator[B]

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

Источник@inline

final override def ++:[B >: Целое](prefix: ИтерируемаяОднажды[B]): AnyAccumulator[B]

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

Источник@inline

final def ++=(xs: ИтерируемаяОднажды[Целое]): IntAccumulator

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

Источник@inline

final def +:[B >: Целое](elem: B): AnyAccumulator[B]

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

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

Источник@inline

final def +=(elem: Целое): IntAccumulator

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

Источник@inline

final def :+[B >: Целое](elem: B): AnyAccumulator[B]

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

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

Источник@inline

final def :++[B >: Целое](suffix: ИтерируемаяОднажды[B]): AnyAccumulator[B]

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

Источник

def addAll(xs: ИтерируемаяОднажды[Целое]): IntAccumulator

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

Источник@inline

final def addString(b: СтрокаСтрока): СтрокаСтрока

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

Добавляет все элементы этой коллекции в строковый буфер, используя строку-разделитель. Записываемый текст состоит из строковых представлений (относительно метода 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 и separator. Текст начинается со строки 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[Int, C]): PartialFunction[Int, C]

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

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

Источник

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

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

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

Источник

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник@unspecialized

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

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

Источник@inline

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

Источник

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

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

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

Источник

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

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

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

Источник

def copyToArray[B >: Int](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 >: Int](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 >: Int](xs: Array[B]): Int

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

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

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

Источник

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

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

Источник

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

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

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

Источник

def diff[B >: Int](that: Seq[B]): IntAccumulator

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

Источник

def distinct: IntAccumulator

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

Источник

def distinctBy[B](f: Int => B): IntAccumulator

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

Источник

def drop(n: Int): IntAccumulator

Источник

def dropRight(n: Int): IntAccumulator

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

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

Источник

def dropWhile(p: Int => Boolean): IntAccumulator

Источник

def elementWise: ElementWiseExtractor[Int, Int]

Возвращает объект-экстрактор с методом 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 >: Int](that: Iterable[B]): Boolean

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

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

Источник

override def equals(o: Any): Boolean

Источник

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

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def groupBy[K](f: Int => K): Map[K, IntAccumulator]

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

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

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

Source

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

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

Source

def groupMapReduce[K, B](key: Int => K)(f: Int => 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)(_ + _)

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

Source

def grouped(size: Int): Iterator[IntAccumulator]

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

Source

override def hashCode(): Int

Source

def head: Int

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

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

Source

def headOption: Option[Int]

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

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

Source@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

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

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

Source

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

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

Source@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

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

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

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

Source

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

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

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

Исходный код@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код

def indices: Range

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

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

Исходный код

def init: IntAccumulator

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

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

Исходный код

def inits: Iterator[IntAccumulator]

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

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

Исходный код

def intersect[B >: Int](that: Seq[B]): IntAccumulator

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

Источник

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: Int

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

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

Источник

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

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

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

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

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

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

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

Источник

def lastIndexOfSlice[B >: Int](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: Int => Boolean): Int

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

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

Источник

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

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

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

Источник

def lastOption: Option[Int]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[Int, B, IntAccumulator]

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

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

Исходный код

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

Исходный код

def mapResult[NewTo](f: IntAccumulator => NewTo): Builder[Int, NewTo]

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код@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 >: Int](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Исходный код

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

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

Исходный код

def partition(p: Int => Boolean): (IntAccumulator, IntAccumulator)

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

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

Исходный код

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

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

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

Исходный код

def permutations: Iterator[IntAccumulator]

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def reverse: IntAccumulator

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

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

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

Источник

def reverseIterator: Iterator[Int]

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

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

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

Источник

protected def reversed: Iterable[Int]

Источник

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

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

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

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

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

Пример:

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def segmentLength(p: Int => 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, вместе с верхней границей, определяемой размером другой коллекции. Некоторые классы билдеров оптимизируют свою структуру на основе этого предположения. Однако реализации билдеров должны работать корректно, даже если предположение ошибочно, то есть, если добавлено разное количество элементов.

Source@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

Source

final def sizeLong: Long

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

Source

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

Source

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

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

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

Source

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

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

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

Source

def sortBy[B](f: Int => B)(implicit ord: Ordering[B]): IntAccumulator

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

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

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

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

Source

def sortWith(lt: (Int, Int) => Boolean): IntAccumulator

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

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

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

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

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

Source

def sorted[B >: Int](implicit ord: Ordering[B]): IntAccumulator

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

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

Source

def span(p: Int => Boolean): (IntAccumulator, IntAccumulator)

Source

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

Source

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

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

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

Source

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

Source

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

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

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

Source

def tail: IntAccumulator

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

Source

def tails: Iterator[IntAccumulator]

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

Source

def take(n: Int): IntAccumulator

Source

def takeRight(n: Int): IntAccumulator

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

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

Source

def takeWhile(p: Int => Boolean): IntAccumulator

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

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

Source

override def tapEach[U](f: Int => U): IntAccumulator

Source

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

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

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[Int]

Source

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

Source

def toSeq: Seq[Int]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[Int]

Source

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

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

Источник

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

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

Источник

def unzip[A1, A2](implicit asPair: Int => (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))

Источник

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

Источник

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

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

Источник

override def view: SeqView[Int]

Источник

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

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

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

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

Источник

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

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

Источник

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

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

Источник

def zipWithIndex: AnyAccumulator[(Int, Int)]