Трейт scala.collection.immutable.SortedMap

трейт SortedMap[K, +V] extends Map[K, V] with SortedMap[K, V] with SortedMapOps[K, V, SortedMap, SortedMap[K, V]] with SortedMapFactoryDefaults[K, V, SortedMap, Iterable, Map]

Неизменяемая карта, пары ключ-значение которой отсортированы по порядку scala.math.Ordering ключей.

Разрешает выполнение запросов по диапазонам ключей, и реализации должны гарантировать, что обход происходит в отсортированном порядке, согласно scala.math.Ordering карты.

import scala.collection.immutable.SortedMap
// Make a SortedMap via the companion object factory
val weekdays = SortedMap(
  2 -> "Monday",
  3 -> "Tuesday",
  4 -> "Wednesday",
  5 -> "Thursday",
  6 -> "Friday"
)
// TreeMap(2 -> Monday, 3 -> Tuesday, 4 -> Wednesday, 5 -> Thursday, 6 -> Friday)
val days = weekdays ++ List(1 -> "Sunday", 7 -> "Saturday")
// TreeMap(1 -> Sunday, 2 -> Monday, 3 -> Tuesday, 4 -> Wednesday, 5 -> Thursday, 6 -> Friday, 7 -> Saturday)
val day3 = days.get(3) // Some("Tuesday")
val rangeOfDays = days.range(2, 5) // TreeMap(2 -> Monday, 3 -> Tuesday, 4 -> Wednesday)
val daysUntil2 = days.rangeUntil(2) // TreeMap(1 -> Sunday)
val daysTo2 = days.rangeTo(2) // TreeMap(1 -> Sunday, 2 -> Monday)
val daysAfter5 = days.rangeFrom(5) //  TreeMap(5 -> Thursday, 6 -> Friday, 7 -> Saturday)

Наследованные классы

Исходный код

защищенный класс ImmutableKeySet extends AbstractSet[K] with DefaultSerializable

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

Исходный код

защищенный класс ImmutableKeySortedSet extends AbstractSet[K] with SortedSet[K]

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

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

Исходный код

переопределенный def sortedMapFactory: SortedMapFactory[SortedMap]

Исходный код

переопределенный def unsorted: Map[K, V]

Исходный код

переопределенный def withDefault[V1 >: V](d: K => V1): SortedMap[K, V1]

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

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

Исходный код

переопределенный def withDefaultValue[V1 >: V](d: V1): SortedMap[K, V1]

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

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

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

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

окончательный переопределенный def +[V1 >: V](kv: (K, V1)): SortedMap[K, V1]

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

окончательный переопределенный def ++[V2 >: V](xs: IterableOnce[(K, V2)]): SortedMap[K, V2]

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

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

окончательный def ++[B >: (K, V)](suffix: IterableOnce[B]): Iterable[B]

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

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

окончательный def -(key: K): SortedMap[K, V]

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

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

окончательный переопределенный def --(keys: IterableOnce[K]): SortedMap[K, V]

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

Source

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

Source@inline

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер. Записываемый текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции без разделителя.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Source@inline

final def addString(b: StringBuilder, sep: String): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер с помощью разделителя. Записываемый текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Source

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

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

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

Source

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

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

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

Source@throws(scala.throws.$lessinit$greater$default$1[scala.NoSuchElementException])

def apply(key: K): V

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

Source

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

Source

def canEqual(that: Any): Boolean

Source

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

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

Source

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

Source

def collect[K2, V2](pf: PartialFunction[(K, V), (K2, V2)])(implicit @implicitNotFound ordering: Ordering[K2]): SortedMap[K2, V2]

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

Source

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

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

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

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

Исходный код

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

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

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

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

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

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

Исходный код

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

Исходный код

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

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

Исходный код

def contains(key: K): Boolean

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

Исходный код

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

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

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

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

Исходный код@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Исходный код@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Исходный код

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

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

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

Источник

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

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

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

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

def default(key: K): V

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

Источник

def drop(n: Int): SortedMap[K, V]

Источник

def dropRight(n: Int): SortedMap[K, V]

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

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

Источник

def dropWhile(p: (K, V) => Boolean): SortedMap[K, V]

Источник

def elementWise: ElementWiseExtractor[K, V]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Источник

override def empty: SortedMap[K, V]

Источник

override def equals(that: Any): Boolean

Источник

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

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

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

Источник

def filter(pred: (K, V) => Boolean): SortedMap[K, V]

Источник

def filterNot(pred: (K, V) => Boolean): SortedMap[K, V]

Источник

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

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

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

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

Источник

def firstKey: K

Источник

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

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

Источник

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

Источник

def flatMap[K2, V2](f: (K, V) => IterableOnce[(K2, V2)])(implicit @implicitNotFound ordering: Ordering[K2]): SortedMap[K2, V2]

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

Источник

def flatten[B](implicit asIterable: (K, V) => IterableOnce[B]): Iterable[B]

Источник

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)]): SortedMap[K, V]

Источник

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

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

Источник

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

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

Источник

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

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

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

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

Источник

def groupMap[K, B](key: (K, V) => K)(f: (K, V) => B): Map[K, Iterable[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций согласно функции-дискриминатору key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

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

Источник

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

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

Источник

def grouped(size: Int): Iterator[SortedMap[K, V]]

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

Источник

override def hashCode(): Int

Источник

def head: (K, V)

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

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

Источник

def headOption: Option[(K, V)]

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

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

Источник

def init: SortedMap[K, V]

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

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

Источник

def inits: Iterator[SortedMap[K, V]]

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

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

Источник

def isDefinedAt(key: K): Boolean

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

Источник

def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[Iterable]

Источник

def iterator: Iterator[(K, V)]

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

Источник

def iteratorFrom(start: K): Iterator[(K, V)]

Создаёт итератор по всем парам ключ/значение, содержащимся в этой карте, имеющим ключ, больший или равный start согласно порядку этой карты. x.iteratorFrom(y) эквивалентно, но часто более эффективно, чем x.from(y).iterator.

Источник

override def keySet: SortedSet[K]

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 keysIteratorFrom(start: K): Iterator[K]

Создаёт итератор по всем ключам (или элементам), содержащимся в этой коллекции, большим или равным start в соответствии с порядком этой коллекции. x.keysIteratorFrom(y) эквивалентно, но часто более эффективно, чем x.from(y).keysIterator.

Source

def knownSize: Int

Source

def last: (K, V)

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

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

Source

def lastKey: K

Source

def lastOption: Option[(K, V)]

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[(K, V), B, SortedMap[K, V]]

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

Вызовы lazyZip могут быть объединены для поддержки более высокого числа аргументов (до 4) без дополнительных расходов на создание и деконструирование промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Source

def lift: K => Option[V]

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

Source

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

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

Source

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

Source

def map[K2, V2](f: (K, V) => (K2, V2))(implicit @implicitNotFound ordering: Ordering[K2]): SortedMap[K2, V2]

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

Source

override def mapFactory: MapFactory[Map]

Source

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

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

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

Source

def maxBefore(key: K): Option[(K, V)]

Находит элемент с наибольшим ключом, меньшим заданного ключа.

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def minAfter(key: K): Option[(K, V)]

Найти элемент с наименьшим ключом, большим или равным заданному ключу.

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Source

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

Отображает все элементы этого набора в строку с использованием строк start, end и separator.

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

Source

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

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

def nonEmpty: Boolean

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

Source

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

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

Source

def ordering: Ordering[K]

Source

def partition(p: (K, V) => Boolean): (SortedMap[K, V], SortedMap[K, V])

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

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

Source

def partitionMap[A1, A2](f: (K, V) => Either[A1, A2]): (Iterable[A1], Iterable[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 range(from: K, until: K): SortedMap[K, V]

Создаёт проекцию этого набора с нижней и верхней границами.

Source

def rangeFrom(from: K): SortedMap[K, V]

Создаёт проекцию этого набора без верхней границы.

Source

def rangeImpl(from: Option[K], until: Option[K]): SortedMap[K, V]

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

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

Source

def rangeTo(to: K): SortedMap[K, V]

Source

def rangeUntil(until: K): SortedMap[K, V]

Создаёт проекцию этого набора без нижней границы.

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Исходный код

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

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

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

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

Исходный код

def removed(key: K): SortedMap[K, V]

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

Исходный код

def removedAll(keys: IterableOnce[K]): SortedMap[K, V]

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

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

Исходный код

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

Исходный код

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

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

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

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

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

Source

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

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

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

Source

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

Source

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

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

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

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

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

Пример:

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

Source

def size: Int

Размер этой коллекции.

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

Source

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

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

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

Source

def sizeCompare(otherSize: Int): Int

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

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

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

final def sizeIs: SizeCompareOps

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

Эти операции реализованы в терминах sizeCompare(Int) и позволяют использовать следующие более читабельные конструкции:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Исходный код

def slice(from: Int, until: Int): SortedMap[K, V]

Исходный код

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

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

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

Исходный код

def sliding(size: Int): Iterator[SortedMap[K, V]]

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

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

Исходный код

def span(p: (K, V) => Boolean): (SortedMap[K, V], SortedMap[K, V])

Исходный код

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

Source

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

Source

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

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

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

Source

def tail: SortedMap[K, V]

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

Source

def tails: Iterator[SortedMap[K, V]]

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

Source

def take(n: Int): SortedMap[K, V]

Source

def takeRight(n: Int): SortedMap[K, V]

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

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

Source

def takeWhile(p: (K, V) => Boolean): SortedMap[K, V]

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

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

Source

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

Source

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

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

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

Source

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

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

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[(K, V)]

Source

def toList: List[(K, V)]

Source

final override def toMap[K2, V2](implicit ev: (K, V) <:< (K2, V2)): Map[K2, V2]

Source

def toSeq: Seq[(K, V)]

Source

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

Источник

override def toString(): String

Источник

def toVector: Vector[(K, V)]

Источник

override def transform[W](f: (K, V) => W): SortedMap[K, W]

Источник

def transpose[B](implicit asIterable: (K, V) => Iterable[B]): Iterable[Iterable[B]]

Транспонирует эту итерируемую коллекцию итерируемых коллекций в итерируемую коллекцию итерируемых коллекций.

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

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

Источник

def unapply(a: K): Option[V]

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

Источник

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

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

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

Источник

def updated[V1 >: V](key: K, value: V1): SortedMap[K, V1]

Источник

override def updatedWith[V1 >: V](key: K)(remappingFunction: Option[V] => Option[V1]): SortedMap[K, V1]

Источник

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

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

Источник

def values: Iterable[V]

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

Источник

def valuesIterator: Iterator[V]

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

Источник

def valuesIteratorFrom(start: K): Iterator[V]

Создаёт итератор по всем значениям, содержащимся в этой карте, которые связаны с ключом, большим или равным start согласно порядку этой карты. x.valuesIteratorFrom(y) эквивалентно, но часто более эффективно, чем x.from(y).valuesIterator.

Источник

override def view: MapView[K, V]

Источник

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

Source

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

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

Source

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

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

Source

def zipWithIndex: Iterable[((K, V), Int)]