Класс LongMap.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^30.

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

Исходный код

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]

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

Исходный код

final def addOne(key: Long, value: V): LongMap.this.type

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

Исходный код

final override def addOne(kv: (Long, V)): LongMap.this.type

Добавляет один элемент в это изменяемое отображение.

Исходный код

override def apply(key: Long): V

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

Исходный код

override def clone(): LongMap[V]

Создает копию объекта-получателя.

По умолчанию реализация метода clone зависит от платформы.

Исходный код

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

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

Источник

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

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

Источник

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

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

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

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

Источник

def getOrNull(key: Long): V

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

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.this.type

Удаляет один элемент из этой изменяемой карты.

Источник

def transformValuesInPlace(f: V => V): LongMap.this.type

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

Источник

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

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

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

Источник

override def valuesIterator: Iterator[V]

Создает итератор для всех значений в этой карте.

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

Источник

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

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

Источник

final def ++=(xs: IterableOnce[(Long, V)]): Growable.this.type

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

Источник

final def +=(elem: (Long, V)): Growable.this.type

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

Источник

final def --=(xs: IterableOnce[Long]): Shrinkable.this.type

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

Источник

final def -=(elem: Long): Shrinkable.this.type

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

Источник

def addAll(xs: IterableOnce[(Long, V)]): Growable.this.type

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Обратите внимание, что выражение 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

Метод, который должен вызываться из каждой хорошо спроектированной функции equals, которая может быть переопределена в подклассе. См. Programming in Scala, Chapter 28 для обсуждения и проектирования.

Источник

def clear(): Unit

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

Источник

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

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

Источник

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

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

Источник

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

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

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

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

Источник

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

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

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

Source

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

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

Source

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

def drop(n: Int): C

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

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

Source

override def dropRight(n: Int): C

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

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

Source

def dropWhile(p: ((Long, V)) => Boolean): C

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

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

Источник

def elementWise: ElementWiseExtractor[A, B]

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

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

• для каждой пары (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): C

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

Источник

def filterInPlace(p: (Long, V) => Boolean): MapOps.this.type

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

Источник

override def filterNot(pred: ((Long, V)) => Boolean): C

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

Исходный код

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

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

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

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

Исходный код

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

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

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Исходный код

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

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

Исходный код

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

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

Источник

override def hashCode(): Int

Вычисляет хэш-код объекта.

Базовый алгоритм хеширования зависит от платформы.

Обратите внимание, что двум объектам разрешено иметь идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)) и при этом не быть равными (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true), у них были идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода убедитесь, что поведение согласуется с методом equals.

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

def isDefinedAt(key: Long): Boolean

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

Источник

override def isTraversableAgain: Boolean

Проверяет, может ли этот итерируемый набор быть повторно пройден. Всегда true для Iterables и false для Iterators, если не переопределено.

Источник

override def iterableFactory: IterableFactory[Iterable]

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

Источник

def keySet: Set[K]

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

Источник

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

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

Источник

def keys: Iterable[K]

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

Источник

def last: A

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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

Аналогично 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: A => Option[B]

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

Исходный код

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

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

Исходный код

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

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

Исходный код

override def mapFactory: MapFactory[Map]

Объект-компаньон этой карты, предоставляющий различные методы фабрики.

Исходный код

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

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

Исходный код

def mapValuesInPlace(f: (Long, V) => V): MapOps.this.type

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

Исходный код

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

Находит максимальный элемент.

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Находит максимальный элемент.

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

Исходный код

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

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

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

Исходный код

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def mkString: String

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

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

Source

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

def nonEmpty: Boolean

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

Source

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

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

Source

override def partition(p: ((Long, V)) => Boolean): (C, C)

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

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

Source

override def partitionMap[A1, A2](f: ((Long, V)) => Either[A1, A2]): (CC[A1], CC[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))

Source

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

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

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

Источник

def result(): C

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

def scanRight[B](z: B)(op: ((Long, V), B) => B): CC[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 вместе с верхним пределом, заданным размером другой коллекции. Некоторые классы билдеров оптимизируют своё представление на основе подсказки. Однако реализации билдеров всё равно должны работать корректно, даже если подсказка неверна, т. е. добавляется другое количество элементов.

Источник

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

Выбирает интервал элементов. Полученная итерируемая коллекция состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

override def span(p: ((Long, V)) => Boolean): (C, C)

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

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

Исходный код

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

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Исходный код

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. Для Steppers, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Steppers могут быть преобразованы только в последовательные потоки.

Исходный код

def subtractAll(xs: IterableOnce[Long]): Shrinkable.this.type

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

Исходный код

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

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

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

Исходный код

def tail: C

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

Исходный код

def tails: Iterator[C]

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

Исходный код

def take(n: Int): C

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

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

Исходный код

override def takeRight(n: Int): C

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

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

Исходный код

def takeWhile(p: ((Long, V)) => Boolean): C

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

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

Исходный код

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

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

Исходный код

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 из этого метода.

Исходный код

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

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

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString(): String

Возвращает строковое представление объекта.

По умолчанию представление зависит от платформы.

Исходный код

def toVector: Vector[A]

Исходный код

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

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

Источник

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

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

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

Источник

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

Вид на элементы этой коллекции.

Источник

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

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

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

Источник

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

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

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

Источник

override def withFilter(p: ((Long, V)) => Boolean): WithFilter[K, V, WithFilterCC, CC]

Создаёт нестрогий фильтр этой карты.

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

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

Источник

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

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

Исходный код

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

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

Исходный код

override def zipWithIndex: CC[(A, Int)]

Объединяет этот итерируемый набор с его индексами.