Класс TrieMap.TrieMap

final class TrieMap[K, V] extends AbstractMap[K, V] with Map[K, V] with MapOps[K, V, TrieMap, TrieMap[K, V]] with MapFactoryDefaults[K, V, TrieMap, Iterable] with DefaultSerializable

Конкуррентное хэш-дерево или TrieMap — это потокобезопасная, неблокирующая реализация хэш-массива, сопоставленного с деревом. Она используется для реализации абстракции конкуррентной карты. Она имеет особенно масштабируемые конкуррентные операции вставки и удаления и является эффективной в плане памяти. Поддерживает атомарные, неблокирующие снимки O(1), которые используются для реализации линеаризуемых неблокирующих операций с размером, итератором и очисткой. Стоимость вычисления (ленивого) снимка распределяется между последующими обновлениями, тем самым обеспечивая горизонтальную масштабируемость вычисления снимка.

Для получения подробной информации см.: http://lampwww.epfl.ch/~prokopec/ctries-snapshot.pdf

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

Исходный код

def this(hashf: Hashing[K], ef: Equiv[K])

Исходный код

def this()

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

Исходный код

def addOne(kv: (K, V)): TrieMap.this.type

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

Исходный код

override def apply(k: K): V

Возвращает значение, связанное с заданным ключом. Этот метод вызывает метод default карты, если нет сопоставления заданного ключа со значением. Если не переопределено, метод default выбрасывает NoSuchElementException.

Исходный код

override def clear(): Unit

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

Исходный код

def computeHash(k: K): Int

Исходный код

def equality: Equiv[K]

Исходный код

def get(k: K): Option[V]

Возвращает значение, связанное с ключом.

Исходный код

override def getOrElseUpdate(k: K, op: => V): V

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

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

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

Исходный код

def hashing: Hashing[K]

Исходный код

override def isEmpty: Boolean

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

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

Исходный код

def isReadOnly: Boolean

Исходный код

def iterator: Iterator[(K, V)]

Итератор можно использовать только один раз

Исходный код

override def keySet: Set[K]

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

Source

override def knownSize: Int

Source

override def mapFactory: MapFactory[TrieMap]

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

Source

def nonReadOnly: Boolean

Source

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

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

Source

def putIfAbsent(k: K, v: V): Option[V]

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

$atomicop

Source

def readOnlySnapshot(): Map[K, V]

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

Моментальное представление обновляется лениво — в первый раз, когда к какому-либо ветвлению этой TrieMap обращаются, оно переписывается. Таким образом, работа по созданию моментального снимка распределяется по последующим обновлениям и обращениям к этой TrieMap всеми потоками. Обратите внимание, что само моментальное представление никогда не переписывается в отличие от вызова метода snapshot, но полученное моментальное представление нельзя изменить.

Этот метод используется другими методами, такими как size и iterator.

Source

override def remove(k: K): Option[V]

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

Source

def remove(k: K, v: V): Boolean

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

$atomicop

Source

def replace(k: K, oldvalue: V, newvalue: V): Boolean

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

$atomicop

Source

def replace(k: K, v: V): Option[V]

Заменяет запись для данного ключа только если она ранее была отображена на какое-то значение.

$atomicop

Source

override def size: Int

Размер этой изменяемой карты.

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

Source

def snapshot(): TrieMap[K, V]

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

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

Source

def string: String

Source

def subtractOne(k: K): TrieMap.this.type

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

Source

override def update(k: K, v: V): Unit

Добавляет новую пару ключ/значение в эту карту. Если в карте уже есть отображение для ключа, оно будет перезаписано новым значением.

Source

override def values: Iterable[V]

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

Source

override def view: MapView[K, V]

Вид на элементы этого набора.

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

Source

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

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

Source

def ++[V2 >: V](xs: IterableOnce[(K, V2)]): CC[K, V2]

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

Source

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

Source

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)

Source

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

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

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

Source

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

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

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

Source

override def applyOrElse[K1 <: K, 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, Глава 28 для обсуждения и проектирования.

Источник

override def clone(): C

Создает копию объекта-приемника.

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

Источник

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

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

Источник

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

def concat[V2 >: V](suffix: IterableOnce[(K, V2)]): CC[K, V2]

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

Source

def contains(key: K): Boolean

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

def default(key: K): V

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

Source

def drop(n: Int): C

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

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

Source

def dropRight(n: Int): C

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

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

Source

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

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

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

Source

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
}

Source

override def empty: CC[K, V]

Пустой итератор того же типа, что и этот итератор

Source

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

Source

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

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

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

Source

def filter(pred: ((K, V)) => Boolean): C

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

Source

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

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

Source

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

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

Source

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

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

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

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

Исходный код

def flatMap[B](f: ((K, 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: ((K, V)) => IterableOnce[(K2, V2)]): CC[K2, V2]

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

Исходный код

def flatten[B](implicit asIterable: ((K, 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 >: (K, V)](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

override protected def fromSpecific(coll: IterableOnce[(K, V)]): CC[K, V]

Определяет, как преобразовать заданную Iterable[A] в коллекцию типа C.

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

Источник

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

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

Источник

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

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

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

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

Источник

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

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

Source

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

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

Source

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

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

Source

override def hashCode(): Int

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

По умолчанию алгоритм хэширования зависит от платформы.

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

Source

def head: A

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

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

Source

def headOption: Option[A]

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

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

Source

def init: C

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

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

Source

def inits: Iterator[C]

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

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

Source

def isDefinedAt(key: K): Boolean

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

Source

override def isTraversableAgain: Boolean

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

Source

override def iterableFactory: IterableFactory[Iterable]

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

Source

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

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

Source

def keys: Iterable[K]

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

Source

def keysIterator: Iterator[K]

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

Source

def last: A

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

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

Source

def lastOption: Option[A]

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

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

Source

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)

Source

def lift: A => Option[B]

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def mkString: String

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

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

Source

final def mkString(sep: String): String

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

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

Исходный код

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

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

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

Исходный код

override protected def newSpecificBuilder: Builder[(K, V), CC[K, V]]

Исходный код

def nonEmpty: Boolean

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

Исходный код

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

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

Исходный код

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

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

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

Source

def partitionMap[A1, A2](f: ((K, 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 >: (K, V)](implicit num: Numeric[B]): B

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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 >: (K, V)](z: B)(op: (B, B) => B): CC[B]

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

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

Исходный код

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

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

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

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

Исходный код

def scanRight[B](z: B)(op: ((K, 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.)

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

Источник

def span(p: ((K, 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[(K, 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[K]): Shrinkable.this.type

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

Источник

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

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

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Источник

def take(n: Int): C

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

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

Источник

def takeRight(n: Int): C

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

def toList: List[A]

Источник

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

Источник

def toSeq: Seq[A]

Источник

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

Источник

override def toString(): String

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

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

Источник

def toVector: Vector[A]

Источник

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

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

Источник

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

Источник

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

Источник

override def updateWith(key: K)(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 valuesIterator: Iterator[V]

Создаёт итератор для всех значений в этом отображении.

Источник

def withDefault(d: K => 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: ((K, V)) => Boolean): WithFilter[K, V, WithFilterCC, CC]

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

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

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

Источник

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

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

Источник

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

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

Источник

def zipWithIndex: CC[(A, Int)]

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