Класс SortedMap.WithDefault

final class WithDefault[K, V](underlying: SortedMap[K, V], defaultValue: K => V) extends WithDefault[K, V] with SortedMap[K, V] with SortedMapOps[K, V, SortedMap, WithDefault[K, V]] with Serializable

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

Исходный код

override def addOne(elem: (K, V)): WithDefault.this.type

Добавляет один элемент в этот изменяемый массив.

Исходный код

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

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

Исходный код

override def empty: WithDefault[K, V]

Пустой перебираемый объект того же типа, что и этот перебираемый объект.

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

override def sortedMapFactory: SortedMapFactory[SortedMap]

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

Исходный код

override def subtractOne(elem: K): WithDefault.this.type

Удаляет один элемент из этого изменяемого массива.

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

Source

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

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

Source

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

Псевдоним для 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

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

Добавляет все элементы этой карты в StringBuilder, используя строки start, end и separator. Записываемый текст начинается со строки 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

Добавляет все элементы этого набора в 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

Добавляет все элементы этого набора в 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 (обратите внимание на его предостережения).

Source

def apply(key: K): V

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

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. Это может привести к лучшей производительности и более предсказуемому поведению относительно побочных эффектов.

Source

def canEqual(that: Any): Boolean

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

Source

override def clear(): Unit

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

Source

override def clone(): C

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

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

Source

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

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

Источник

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

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

Источник

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

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

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

Источник

override def default(key: K): V

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

Источник

def drop(n: Int): C

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

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

Источник

def dropRight(n: Int): C

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

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

Источник

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

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

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

Источник

def elementWise: ElementWiseExtractor[A, B]

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

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

Источник

override def equals(that: Any): Boolean

Равенство карт реализуется с помощью метода поиска get. Этот метод возвращает true, если

• аргумент o является Map,

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

• для каждой (key, value) пары в этой карте, other.get(key) == Some(value).

Реализация equals проверяет метод canEqual, поэтому подклассы Map могут сузить равенство до определённых типов карт. Реализации Map в стандартной библиотеке могут сравниваться, их методы canEqual возвращают true.

Примечание: метод equals соблюдает законы равенства (симметричность, транзитивность) только если две карты используют одну и ту же функцию эквивалентности ключей в своей операции поиска. Например, операция эквивалентности ключей в scala.collection.immutable.TreeMap определяется её порядком. Сравнение TreeMap с HashMap приводит к непредсказуемым результатам, если ordering.equiv(k1, k2) (используемая для поиска в TreeMap ) отличается от k1 == k2 (используемая для поиска в HashMap).

scala> import scala.collection.immutable._
scala> val ord: Ordering[String] = _ compareToIgnoreCase _

scala> TreeMap("A" -> 1)(ord) == HashMap("a" -> 1)
val res0: Boolean = false

scala> HashMap("a" -> 1) == TreeMap("A" -> 1)(ord)
val res1: Boolean = true

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

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

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

Источник

def firstKey: K

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

Источник

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

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

Источник

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)])(implicit ordering: Ordering[K2]): 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.

Исходный код

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

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

Исходный код

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

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

Source

def getOrElseUpdate(key: K, op: => V): V

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

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

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

Source

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

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

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

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

Source

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 isEmpty: Boolean

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

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

Исходный код

override def isTraversableAgain: Boolean

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

Исходный код

override def iterableFactory: IterableFactory[Iterable]

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

Исходный код

def iterator: Iterator[(K, V)]

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

Исходный код

override def keySet: SortedSet[K]

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

Исходный код

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

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

Исходный код

def keys: Iterable[K]

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

Исходный код

def keysIterator: Iterator[K]

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

Исходный код

override def knownSize: Int

Исходный код

def last: A

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

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

Исходный код

def lastKey: K

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

Исходный код

def lastOption: Option[A]

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

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

Исходный код

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

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

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

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

Исходный код

def lift: A => Option[B]

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

Исходный код

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

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

Исходный код

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

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

Источник

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

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

Источник

override def mapFactory: MapFactory[Map]

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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, который может быть переопределён.

Источник

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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, которая требует только одного прохода.

Источник

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

Источник

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

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

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

Источник

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

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

Источник

def range(from: K, until: K): C

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

Источник

def rangeFrom(from: K): C

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

Источник

def rangeTo(to: K): C

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

Источник

def rangeUntil(until: K): C

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

Источник

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]

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

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

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

Исходный код

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

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

Исходный код

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 size: Int

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

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

Источник

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

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

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

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

Source

def sizeHint(size: Int): Unit

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

Source

final def sizeHintBounded(size: Int, boundingColl: Iterable[_]): Unit

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

Source

final def sizeIs: SizeCompareOps

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

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

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

Source

def slice(from: Int, until: Int): C

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

from <= indexOf(x) < until

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

Source

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

Источник

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

Исходный код

override def unsorted: Map[K, V]

Исходный код

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

Исходный код

def update(key: K, value: V): Unit

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

Исходный код

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

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

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

Источник

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

Та же карта со заданным значением по умолчанию. Примечание: значение по умолчанию используется только для 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 операций.

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

Источник

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

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

Неявные значения

Источник

implicit def ordering: Ordering[K]