Класс TreeMap.TreeMap

final class TreeMap[K, +V] extends AbstractMap[K, V] with SortedMap[K, V] with StrictOptimizedSortedMapOps[K, V, TreeMap, TreeMap[K, V]] with SortedMapFactoryDefaults[K, V, TreeMap, Iterable, Map] with DefaultSerializable

Неизменяемый SortedMap, значения которого хранятся в красно-чёрном дереве.

Этот класс оптимален, когда будут выполняться запросы по диапазону или когда требуется обход в порядке заданного упорядочения. Если вам нужны только поиски по ключу и неважно, в каком порядке итерации по парам ключ-значение, используйте * scala.collection.immutable.HashMap, который, как правило, имеет лучшую производительность. Если вам нужна последовательность вставки, рассмотрите * scala.collection.immutable.SeqMap, которому не нужно задавать упорядочение.

import scala.collection.immutable.TreeMap
// Make a TreeMap via the companion object factory
val weekdays = TreeMap(
  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)

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

Исходный код

protected class ImmutableKeySet extends AbstractSet[K] with DefaultSerializable

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

Исходный код

protected class ImmutableKeySortedSet extends AbstractSet[K] with SortedSet[K]

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

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

Исходный код

def this()(implicit ordering: Ordering[K])

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

Исходный код

override def concat[V1 >: V](that: IterableOnce[(K, V1)]): TreeMap[K, V1]

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

override def equals(obj: 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

Исходный код

override def filter(f: ((K, V)) => Boolean): TreeMap[K, V]

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

Исходный код

override def firstKey: K

Возвращает первый ключ коллекции.

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

override def head: (K, V)

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

Исходный код

override def init: TreeMap[K, V]

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

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

Исходный код

override def isEmpty: Boolean

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

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

Исходный код

def iterator: Iterator[(K, V)]

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

Исходный код

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

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

Исходный код

override def keySet: TreeSet[K]

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

Исходный код

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

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

Исходный код

def keysIteratorFrom(start: K): Iterator[K]

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

Source

override def knownSize: Int

Source

override def last: (K, V)

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

Source

override def lastKey: K

Возвращает последний ключ коллекции.

Source

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

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

Source

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

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

Source

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

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

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

Source

override def range(from: K, until: K): TreeMap[K, V]

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

Source

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

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

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

Source

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

Удаляет ключ из этого отображения, возвращая новое отображение.

Source

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

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

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

Source

override def size: Int

Размер этого неизменяемого дерева отображений.

Source

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

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

from <= indexOf(x) < until

Source

override def sortedMapFactory: SortedMapFactory[TreeMap]

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

Source

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

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

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

Источник

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[(K, V), S]): S & EfficientSplit

Возвращает 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 могут быть преобразованы только в последовательные потоки.

Источник

override def tail: TreeMap[K, V]

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

Источник

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

final override def +[V1 >: V](kv: (K, V1)): CC[K, V1]

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

Источник

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

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

Источник

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

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

Источник

final def -(key: K): C

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

Источник

final override def --(keys: IterableOnce[K]): C

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

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

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

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

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

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

Source

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

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

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

Источник

def apply(key: K): V

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

Источник

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, Chapter 28 для обсуждения и проектирования.

Источник

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

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

Источник

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

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

Источник

override def collect[K2, V2](pf: PartialFunction[(K, V), (K2, V2)])(implicit ordering: Ordering[K2]): 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 contains(key: K): Boolean

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

Источник

def default(key: K): V

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

Источник

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 empty: CC[K, V]

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

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

Источник

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

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

Источник

override 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)

Источник

override def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2]

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

Источник

override def flatten[B](implicit toIterableOnce: ((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

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

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

Источник

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

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

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

Источник

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)

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

Исходный код

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[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 headOption: Option[A]

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

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

Исходный код

def inits: Iterator[C]

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

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

Исходный код

def isDefinedAt(key: K): Boolean

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

Исходный код

override def isTraversableAgain: Boolean

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

Исходный код

override def iterableFactory: IterableFactory[Iterable]

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

Исходный код

def keys: Iterable[K]

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

Исходный код

def keysIterator: Iterator[K]

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

Исходный код

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

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

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

Source

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

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

Source

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

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

Source

override def mapFactory: MapFactory[Map]

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

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Source

def nonEmpty: Boolean

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

Source

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

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

Source

override 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 rangeFrom(from: K): C

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

Source

def rangeTo(to: K): C

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

Source

def rangeUntil(until: K): C

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

Source

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]

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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 может применяться более одного раза.

Источник

override 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 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 sliding(size: Int, step: Int): Iterator[C]

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

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

Источник

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

def tails: Iterator[C]

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

Исходный код

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

Применяет функцию со побочным эффектом к каждому элементу в этом наборе. Строгие наборы немедленно применяют f к своим элементам, в то время как ленивые наборы, такие как представления и 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]

Исходный код

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

Исходный код

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 в выражении сопоставления с образцом.

Исходный код

override def unsorted: Map[K, V]

Исходный код

override 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))

Исходный код

override 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 updatedWith[V1 >: V](key: K)(remappingFunction: Option[V] => Option[V1]): CC[K, V1]

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

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

Исходный код

def values: Iterable[V]

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

Исходный код

def valuesIterator: Iterator[V]

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

Исходный код

override def view: MapView[K, V]

Представление над элементами этой коллекции.

Исходный код

override def withDefault[V1 >: V](d: K => V1): SortedMap[K, V1]

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

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

Исходный код

override def withDefaultValue[V1 >: V](d: V1): SortedMap[K, V1]

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

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

Исходный код

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

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

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

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

Источник

override 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)]

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

Источник

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

Объединяет эту итерируемую коллекцию со своими индексами.

Неявные параметры

Источник

implicit val ordering: Ordering[K]