Класс scala.collection.mutable.LongMap

final class LongMap[V] extends AbstractMap[Long, V] with MapOps[Long, V, Map, LongMap[V]] with StrictOptimizedIterableOps[(Long, V), Iterable, LongMap[V]] with Serializable

Этот класс реализует изменяемые карты с Long ключами, основанными на хэш-таблице с открытым адресованием.

Основные операции над картой для отдельных записей, включая contains и get, обычно значительно быстрее с LongMap по сравнению с HashMap. Методы, которые действуют над всей картой, включая foreach и map, как правило, не ожидаются быстрее, чем с универсальной картой, за исключением тех, которые используют специфические особенности внутренней структуры карты: foreachKey, foreachValue, mapValuesNow, и transformValues.

Карты с открытым адресованием могут стать менее эффективными при поиске после многократного добавления/удаления элементов. Хотя LongMap делает хорошую попытку оставаться эффективными независимо, вызов repack для карты, которая больше не будет использоваться для удаления элементов, но будет интенсивно использоваться, может сэкономить и время, и место в памяти.

Эта карта не предназначена для хранения более чем 229 элементов (приблизительно 500 миллионов). Максимальная ёмкость составляет 230, но производительность быстро снизится, приближаясь к 2³⁰.

Конструкторы

Исходный код

def this()

Исходный код

def this(defaultEntry: Long => V)

Создаёт новую LongMap, которая возвращает значения по умолчанию согласно предоставленному соответствию ключ-значение.

Исходный код

def this(initialBufferSize: Int)

Создаёт новую LongMap с начальным буфером заданного размера.

LongMap, как правило, может содержать вдвое меньше элементов, чем размер буфера, прежде чем потребуется изменение размера.

Исходный код

def this(defaultEntry: Long => V, initialBufferSize: Int)

Создаёт новую LongMap со значениями по умолчанию и начальным размером буфера.

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

Исходный код

override def ++[V1 >: V](xs: IterableOnce[(Long, V1)]): LongMap[V1]

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

final def addOne(key: Long, value: V): LongMap[V]

Добавляет новую пару ключ/значение в эту карту и возвращает карту.

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

final override def addOne(kv: (Long, V)): LongMap[V]

Исходный код

override def apply(key: Long): V

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

Исходный код

override def clone(): LongMap[V]

Исходный код

def collect[V2](pf: PartialFunction[(Long, V), (Long, V2)]): LongMap[V2]

Исходный код

override def concat[V1 >: V](xs: IterableOnce[(Long, V1)]): LongMap[V1]

Исходный код

override def contains(key: Long): Boolean

Исходный код

override def default(key: Long): V

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

Исходный код

override def empty: LongMap[V]

Источник

def flatMap[V2](f: (Long, V) => IterableOnce[(Long, V2)]): LongMap[V2]

Источник

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

Источник

override def foreachEntry[U](f: (Long, V) => U): Unit

Источник

def foreachKey[A](f: Long => A): Unit

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

Источник

def foreachValue[A](f: V => A): Unit

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

Источник

override def get(key: Long): Option[V]

Источник

override def getOrElse[V1 >: V](key: Long, default: => V1): V1

Источник

override def getOrElseUpdate(key: Long, defaultValue: => V): V

Источник

def getOrNull(key: Long): V

Возвращает значение, связанное с ключом, или значение по умолчанию для этого типа, если его нет (null для AnyRef, 0 для чисел с плавающей точкой и целых чисел).

Примечание: это самый быстрый способ получить значение, которое может или не может существовать, если значение по умолчанию null/ноль приемлемо. Для пар ключ/значение, которые существуют, apply (т.е. map(key)) также быстро.

Источник

override def isEmpty: Boolean

Источник

def iterator: Iterator[(Long, V)]

Источник

override def keysIterator: Iterator[Long]

Источник

override def knownSize: Int

Источник

def map[V2](f: (Long, V) => (Long, V2)): LongMap[V2]

Источник

def mapValuesNow[V1](f: V => V1): LongMap[V1]

Создает новую LongMap с другими значениями. В отличие от mapValues, этот метод сразу же генерирует новую коллекцию.

Источник

override def put(key: Long, value: V): Option[V]

Источник

def repack(): Unit

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

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

Источник

override def size: Int

Источник

def subtractOne(key: Long): LongMap[V]

Источник

def transformValuesInPlace(f: V => V): LongMap[V]

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

Источник

override def update(key: Long, value: V): Unit

Обновляет карту, чтобы включить новую пару ключ-значение.

Это самый быстрый способ добавить запись в LongMap.

Источник

override def valuesIterator: Iterator[V]

Inherited methods

Источник@inline

final def ++[B >: (Long, V)](suffix: IterableOnce[B]): Iterable[B]

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

Источник@inline

final def ++=(xs: IterableOnce[(Long, V)]): LongMap[V]

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

Источник@inline

final def +=(elem: (Long, V)): LongMap[V]

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

Источник@inline

final def --=(xs: IterableOnce[Long]): LongMap[V]

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

Источник@inline

final def -=(elem: Long): LongMap[V]

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

Источник

def addAll(xs: IterableOnce[(Long, V)]): LongMap[V]

Добавляет все элементы, полученные из 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: 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

Источник

override def addString(sb: StringBuilder, start: String, sep: String, end: String): StringBuilder

Источник

def andThen[C](k: PartialFunction[V, C]): PartialFunction[Long, C]

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

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

Источник

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

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

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

Источник

override def applyOrElse[K1 <: Long, V1 >: V](x: K1, default: K1 => V1): V1

Источник

def canEqual(that: Any): Boolean

Источник

def clear(): Unit

Источник

override def collect[B](pf: PartialFunction[(Long, V), B]): Iterable[B]

Источник

def collect[K2, V2](pf: PartialFunction[(Long, V), (K2, V2)]): Map[K2, V2]

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

Source

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

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

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

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

Source

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

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

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

Source@unspecialized

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

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

Source

def concat[B >: (Long, V)](suffix: IterableOnce[B]): Iterable[B]

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

Source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def count(p: (Long, V) => Boolean): Int

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

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

Источник

def drop(n: Int): LongMap[V]

Источник

override def dropRight(n: Int): LongMap[V]

Остальная часть коллекции без её n последних элементов. Для линейных неизменяемых коллекций это должно избегать создания копии.

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

Источник

def dropWhile(p: (Long, V) => Boolean): LongMap[V]

Источник

def elementWise: ElementWiseExtractor[Long, V]

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

Источник

override def equals(o: Any): Boolean

Равенство карт реализуется с помощью метода поиска get. Этот метод возвращает true если

• аргумент o является Map,

• две карты имеют одинаковый размер, и

• для каждой (key, value) пары в этой карте, other.get(key) == Some(value).

Реализация equals проверяет метод canEqual, поэтому подклассы Map могут сузить равенство до конкретных типов карт. Реализации Map в стандартной библиотеке могут быть все сравнимы, их методы canEqual возвращают true.

Примечание: метод equals учитывает законы равенства (симметрия, транзитивность) только в том случае, если две карты используют одну и ту же функцию эквивалентности ключей в своей операции поиска. Например, операция эквивалентности ключей в scala.collection.immutable.TreeMap определяется его порядком. Сравнение TreeMap с HashMap приводит к неожиданным результатам, если ordering.equiv(k1, k2) (используемая для поиска в TreeMap) отличается от k1 == k2 (используемая для поиска в HashMap).

scala> import scala.collection.immutable._
scala> val ord: Ordering[String] = _ compareToIgnoreCase _

scala> TreeMap("A" -> 1)(ord) == HashMap("a" -> 1)
val res0: Boolean = false

scala> HashMap("a" -> 1) == TreeMap("A" -> 1)(ord)
val res1: Boolean = true

Источник

def exists(p: (Long, V) => Boolean): Boolean

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

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

Источник

override def filter(pred: (Long, V) => Boolean): LongMap[V]

Источник

def filterInPlace(p: (Long, V) => Boolean): LongMap[V]

Сохраняет только те сопоставления, для которых предикат p возвращает true.

Источник

override def filterNot(pred: (Long, V) => Boolean): LongMap[V]

Источник

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

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

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

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

Источник

override def flatMap[B](f: (Long, V) => IterableOnce[B]): Iterable[B]

Источник

def flatMap[K2, V2](f: (Long, V) => IterableOnce[(K2, V2)]): Map[K2, V2]

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

Источник

override def flatten[B](implicit toIterableOnce: (Long, V) => IterableOnce[B]): Iterable[B]

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def forall(p: (Long, V) => Boolean): Boolean

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

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

Source

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

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

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

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

Источник

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

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

Источник

override def hashCode(): Int

Источник

def head: (Long, V)

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

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

Источник

def headOption: Option[(Long, V)]

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

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

Источник

def init: LongMap[V]

Часть набора без последнего элемента.

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

Источник

def inits: Iterator[LongMap[V]]

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

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

Источник

def isDefinedAt(key: Long): Boolean

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

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[Iterable]

Источник

def keySet: Set[Long]

Собирает все ключи этой карты в множество.

Источник

def keyStepper[S <: Stepper[_]](implicit shape: StepperShape[Long, S]): S

Возвращает шагатель Stepper для ключей этой карты. См. метод stepper.

Источник

def keys: Iterable[Long]

Собирает все ключи этой карты в итерируемый набор.

Источник

def last: (Long, V)

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

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

Источник

def lastOption: Option[(Long, V)]

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

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

Источник

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

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

Источник

def lift: Long => Option[V]

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

Источник

override def map[B](f: (Long, V) => B): Iterable[B]

Источник

def map[K2, V2](f: (Long, V) => (K2, V2)): Map[K2, V2]

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

Источник

override def mapFactory: MapFactory[Map]

Источник

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

Построитель, полученный из этого строителя путём отображения результата с помощью f.

Источник

def mapValuesInPlace(f: (Long, V) => V): LongMap[V]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@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 <: Long, B1 >: V](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Источник

override def partition(p: (Long, V) => Boolean): (LongMap[V], LongMap[V])

Источник

override def partitionMap[A1, A2](f: (Long, V) => Either[A1, A2]): (Iterable[A1], Iterable[A2])

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def remove(key: Long): Option[V]

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

Source

def result(): LongMap[V]

Source

protected def reversed: Iterable[(Long, V)]

Source

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

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

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

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

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

Source

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

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

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

Source

override def scanLeft[B](z: B)(op: (B, (Long, V)) => B): Iterable[B]

Source

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

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

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

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

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

Пример:

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

Источник

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

Сравнивает размер этого итерируемого набора с размером другого набора Iterable.

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

Источник

def sizeCompare(otherSize: Int): Int

Сравнивает размер этого итерируемого набора со значением.

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Источник

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): LongMap[V]

Источник

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

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

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

Источник

def sliding(size: Int): Iterator[LongMap[V]]

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

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

Источник

override def span(p: (Long, V) => Boolean): (LongMap[V], LongMap[V])

Источник

override def splitAt(n: Int): (LongMap[V], LongMap[V])

Источник

def stepper[S <: Stepper[_]](implicit shape: StepperShape[(Long, V), S]): S

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

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

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

• Для наборов Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для наборов Double или Float, возвращается scala.collection.DoubleStepper

• Для наборов Long, возвращается scala.collection.LongStepper

• Для любого другого типа элемента возвращается scala.collection.AnyStepper

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

Источник

def subtractAll(xs: IterableOnce[Long]): LongMap[V]

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

Источник

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

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

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

Источник

def tail: LongMap[V]

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

Источник

def tails: Iterator[LongMap[V]]

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

Источник

def take(n: Int): LongMap[V]

Источник

override def takeRight(n: Int): LongMap[V]

Набор, содержащий последние n элементы этого набора.

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

Источник

def takeWhile(p: (Long, V) => Boolean): LongMap[V]

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

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

Источник

override def tapEach[U](f: (Long, V) => U): LongMap[V]

Источник

def to[C1](factory: Factory[(Long, V), C1]): C1

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

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

Источник

def toArray[B >: (Long, V) : ClassTag]: Array[B]

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

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

Источник@inline

final def toBuffer[B >: (Long, V)]: Buffer[B]

Источник

def toIndexedSeq: IndexedSeq[(Long, V)]

Источник

def toList: List[(Long, V)]

Источник

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

Источник

def toSeq: Seq[(Long, V)]

Источник

def toSet[B >: (Long, V)]: Set[B]

Источник

override def toString(): String

Источник

def toVector: Vector[(Long, V)]

Источник

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

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

Источник

override def unzip[A1, A2](implicit asPair: (Long, V) => (A1, A2)): (Iterable[A1], Iterable[A2])

Источник

override def unzip3[A1, A2, A3](implicit asTriple: (Long, V) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

Источник

def updateWith(key: Long)(remappingFunction: Option[V] => Option[V]): Option[V]

Обновляет отображение для указанного ключа и его текущего значения, которое может быть отображено (Some если есть текущее отображение, None если нет).

Если функция переназначения возвращает Some(v), отображение обновляется с новым значением v. Если функция переназначения возвращает None, отображение удаляется (или остается отсутствующим, если оно изначально отсутствовало). Если сама функция вызывает исключение, исключение повторно выбрасывается, и текущее отображение остается без изменений.

Источник

def valueStepper[S <: Stepper[_]](implicit shape: StepperShape[V, S]): S

Возвращает Stepper для значений этого отображения. См. метод stepper.

Источник

def values: Iterable[V]

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

Источник

override def view: MapView[Long, V]

Источник

def withDefault(d: Long => V): Map[Long, V]

То же отображение с заданной функцией по умолчанию. Примечание: по умолчанию используется только для apply. Другие методы, такие как get, contains, iterator, keys, и т. д., не влияют на withDefaultValue.

Вызов методов преобразования (например, map) не сохранит значение по умолчанию.

Источник

def withDefaultValue(d: V): Map[Long, V]

То же отображение со значением по умолчанию. Примечание: по умолчанию используется только для apply. Другие методы, такие как get, contains, iterator, keys, и т. д., не влияют на withDefaultValue.

Вызов методов преобразования (например, map) не сохранит значение по умолчанию.

Источник

override def withFilter(p: (Long, V) => Boolean): WithFilter[Long, V, Iterable, Map]

Источник

override def zip[B](that: IterableOnce[B]): Iterable[((Long, V), B)]

Источник

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

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

Источник

override def zipWithIndex: Iterable[((Long, V), Int)]