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

sealed abstract class LongMap[+T] extends AbstractMap[Long, T] with StrictOptimizedMapOps[Long, T, Map, LongMap[T]] with Serializable

Специализированная неизменяемая структура карты для ключей типа long, основанная на Быстрых Объединяемых Картах Long Окасаки и Гилла. В основном представляет собой дерево, основанное на двоичных разрядах целых чисел.

Примечание: этот класс с версии 2.8 в значительной степени устарел в пользу HashMap.

Наследуемые классы

Исходный код

protected class ImmutableKeySet extends AbstractSet[K] with DefaultSerializable

Реализующий класс множества, возвращаемого keySet

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

Исходный код

override def +[S >: T](kv: (Long, S)): LongMap[S]

Исходный код

def ++[S >: T](that: LongMap[S]): LongMap[S]

Исходный код

override def ++[V1 >: T](that: IterableOnce[(Long, V1)]): LongMap[V1]

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

final override def apply(key: Long): T

Исходный код

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

Исходный код

override def concat[V1 >: T](that: IterableOnce[(Long, V1)]): LongMap[V1]

Исходный код

override def empty: LongMap[T]

Исходный код

override def filter(f: (Long, T) => Boolean): LongMap[T]

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

final def firstKey: Long

Исходный код

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

Исходный код

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

Перебирает пары ключ-значение карты в порядке возрастания ключей.

Исходный код

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

Исходный код

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

Перебирает ключи карты. То же, что и keys.foreach(f), но может быть более эффективным.

Исходный код

final def foreachValue[U](f: T => U): Unit

Перебирает значения карты. То же, что и values.foreach(f), но может быть более эффективным.

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

final def get(key: Long): Option[T]

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

final override def getOrElse[S >: T](key: Long, default: => S): S

Source

def intersection[R](that: LongMap[R]): LongMap[T]

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

Source

def intersectionWith[S, R](that: LongMap[S], f: (Long, T, S) => R): LongMap[R]

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

Source

override def isEmpty: Boolean

Source

def iterator: Iterator[(Long, T)]

Итератор по парам ключ-значение карты в порядке возрастания ключей.

Source

override def keysIterator: Iterator[Long]

Source

override def knownSize: Int

Source@tailrec

final def lastKey: Long

Source

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

Source

def modifyOrRemove[S](f: (Long, T) => Option[S]): LongMap[S]

Функция, совмещающая трансформацию и фильтрацию. Возвращает LongMap таким образом, что для каждого отображения (key, value) в этой карте, если f(key, value) == None карта не содержит отображения для ключа, и если f(key, value).

Source

def removed(key: Long): LongMap[T]

Source

final override def size: Int

Source

override def toList: List[(Long, T)]

Source

override def transform[S](f: (Long, T) => S): LongMap[S]

Source

def unionWith[S >: T](that: LongMap[S], f: (Long, S, S) => S): LongMap[S]

Объединение карты с картой that с использованием комбинирующей функции для разрешения конфликтов.

Source

def updateWith[S >: T](key: Long, value: S, f: (T, S) => S): LongMap[S]

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

Эквивалентно

this.get(key) match {
  case None => this.update(key, value)
  case Some(oldvalue) => this.update(key, f(oldvalue, value)
}

Source

override def updated[S >: T](key: Long, value: S): LongMap[S]

Source

override def valuesIterator: Iterator[T]

Inherited methods

Source@inline

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

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

Source@inline

final def -(key: Long): LongMap[T]

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

Source@inline

final override def --(keys: IterableOnce[Long]): LongMap[T]

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

Исходный код@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[T, C]): PartialFunction[Long, C]

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

def canEqual(that: Any): Boolean

Исходный код

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Source@unspecialized

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

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

Source

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

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

Source

def contains(key: Long): Boolean

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

Source

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

def default(key: Long): T

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

Источник

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

Источник

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

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

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

Источник

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

Источник

def elementWise: ElementWiseExtractor[Long, T]

Возвращает объект извлекателя с методом 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, T) => Boolean): Boolean

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

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

Источник

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

Источник

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

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

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

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

Источник

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

Источник

override def hashCode(): Int

Источник

def head: (Long, T)

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

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

Источник

def headOption: Option[(Long, T)]

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

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

Источник

def init: LongMap[T]

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

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

Источник

def inits: Iterator[LongMap[T]]

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

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

Источник

def isDefinedAt(key: Long): Boolean

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

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[Iterable]

Источник

override def keySet: Set[Long]

Источник

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

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

Источник

def keys: Iterable[Long]

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

Источник

def last: (Long, T)

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

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

Источник

def lastOption: Option[(Long, T)]

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

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

Источник

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

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

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

Источник

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

Источник

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

Источник

override def mapFactory: MapFactory[Map]

Источник

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

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

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

Источник

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source@inline

final def mkString: String

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

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

Source@inline

final def mkString(sep: String): String

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

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

Source

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

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

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

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

Проверяет, не является ли коллекция пустой.

Source

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

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def removedAll(keys: IterableOnce[Long]): LongMap[T]

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

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

Source

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

Source

def runWith[U](action: T => 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, T)](z: B)(op: (B, B) => B): Iterable[B]

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

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

Source

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

Source

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

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

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

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

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

Пример:

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

Source

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

Source

def sizeCompare(otherSize: Int): Int

Сравнивает размер этой итерируемой коллекции со значением теста.

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

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

def slice(from: Int, until: Int): LongMap[T]

Source

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

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

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

Source

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

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

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

Источник

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

Источник

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

Источник

def stepper[S <: Stepper[_]](implicit shape: StepperShape[(Long, T), 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 sum[B >: (Long, T)](implicit num: Numeric[B]): B

Суммирует элементы этой коллекции.

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

Источник

def tail: LongMap[T]

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

Источник

def tails: Iterator[LongMap[T]]

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

Источник

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

Преобразует коллекцию в массив.

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

Источник@inline

final def toBuffer[B >: (Long, T)]: Буфер[B]

Источник

def toIndexedSeq: ИндексированнаяПоследовательность[(Long, T)]

Источник

final override def toMap[K2, V2](implicit ev: (Long, T) <:< (K2, V2)): Карта[K2, V2]

Источник

def toSeq: Последовательность[(Long, T)]

Источник

def toSet[B >: (Long, T)]: Множество[B]

Источник

override def toString(): Строка

Источник

def toVector: Вектор[(Long, T)]

Источник

def transpose[B](implicit asIterable: (Long, T) => Итерируемый[B]): Итерируемый[Итерируемый[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): Вариант[T]

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

Источник

override def unzip[A1, A2](implicit asPair: (Long, T) => (A1, A2)): (Итерируемый[A1], Итерируемый[A2])

Источник

override def unzip3[A1, A2, A3](implicit asTriple: (Long, T) => (A1, A2, A3)): (Итерируемый[A1], Итерируемый[A2], Итерируемый[A3])

Источник

def updatedWith[V1 >: T](key: Long)(remappingFunction: Вариант[T] => Вариант[V1]): Карта[Long, V1]

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

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

Источник

def valueStepper[S <: Степпер[_]](implicit shape: StepperShape[T, S]): S

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

Источник

def values: Итерируемый[T]

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

Источник

override def view: MapView[Long, T]

Источник

def withDefault[V1 >: T](d: Long => V1): Карта[Long, V1]

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

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

Источник

def withDefaultValue[V1 >: T](d: V1): Карта[Long, V1]

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

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

Источник

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

Источник

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

Источник

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

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

Источник

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