Класс scala.collection.mutable.HashMap

@deprecatedInheritance("HashMap будет объявлен final; используйте .withDefault для распространённого случая вычисления значения по умолчанию", "2.13.0")

class HashMap[K, V](initialCapacity: Int, loadFactor: Double) extends AbstractMap[K, V] with MapOps[K, V, HashMap, HashMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, HashMap[K, V]] with StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]] with MapFactoryDefaults[K, V, HashMap, Iterable] with Serializable

Этот класс реализует изменяемые отображения с использованием хеш-таблицы.

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

Исходный код

def this()

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

Исходный код

override def addAll(xs: IterableOnce[(K, V)]): HashMap[K, V]

Исходный код

def addOne(elem: (K, V)): HashMap[K, V]

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

override def apply(key: K): V

Source

override def clear(): Unit

Source

override def contains(key: K): Boolean

Source

override def filterInPlace(p: (K, V) => Boolean): HashMap[K, V]

Source

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

Source

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

Source

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

Source

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

Source

override def getOrElseUpdate(key: K, defaultValue: => V): V

Source

override def hashCode: Int

Source

override def isEmpty: Boolean

Source

override def iterator: Iterator[(K, V)]

Source

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

Source

override def keysIterator: Iterator[K]

Source

override def knownSize: Int

Source

override def mapFactory: MapFactory[HashMap]

Source

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

Source

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

Source

override def size: Int

Source

override def sizeHint(size: Int): Unit

Source

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

Source

override def subtractAll(xs: IterableOnce[K]): HashMap[K, V]

Source

def subtractOne(elem: K): HashMap[K, V]

Source

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

Source

override def updateWith(key: K)(remappingFunction: Option[V] => Option[V]): Option[V]

Source

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

Source

override def valuesIterator: Iterator[V]

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

Source@inline

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

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

Source

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

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

Source@inline

final def ++=(xs: IterableOnce[(K, V)]): HashMap[K, V]

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

Source@inline

final def +=(elem: (K, V)): HashMap[K, V]

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

Source@inline

final def --=(xs: IterableOnce[K]): HashMap[K, V]

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

Source@inline

final def -=(elem: K): HashMap[K, V]

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

Source@inline

final def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

Source@inline

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

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

Пример:

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

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

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

def canEqual(that: Any): Boolean

Источник

override def clone(): HashMap[K, V]

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

Source@unspecialized

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

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

Source

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

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

Источник

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

Источник

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

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

def default(key: K): V

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

Источник

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

Источник

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

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

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

Источник

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

Source

def elementWise: ElementWiseExtractor[K, V]

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

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

Source

override def empty: HashMap[K, V]

Source

override def equals(o: Any): Boolean

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

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

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

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

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

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

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

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

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

Source

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

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

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

Source

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

Source

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

Исходный код

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

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

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

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

Источник

def groupMapReduce[K, B](key: (K, V) => K)(f: (K, V) => B)(reduce: (B, B) => B): Map[K, B]

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

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

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

Источник

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

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

Источник

def head: (K, V)

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

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

Источник

def headOption: Option[(K, V)]

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

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

Источник

def init: HashMap[K, V]

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

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

Источник

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

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

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

Исходный код

def isDefinedAt(key: K): Boolean

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

Исходный код

override def isTraversableAgain: Boolean

Исходный код

override def iterableFactory: IterableFactory[Iterable]

Исходный код

def keySet: Set[K]

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

Исходный код

def keys: Iterable[K]

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

Исходный код

def last: (K, V)

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

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

Исходный код

def lastOption: Option[(K, V)]

Возвращает последний элемент в виде Option.

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

Исходный код

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

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

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

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

Источник

def lift: K => Option[V]

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

Источник

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

Источник

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

Источник

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

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

Источник

def mapValuesInPlace(f: (K, V) => V): HashMap[K, V]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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

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

def nonEmpty: Boolean

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

Source

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

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

Source

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

Source

override def partitionMap[A1, A2](f: (K, V) => Either[A1, A2]): (Iterable[A1], Iterable[A2])

Source

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

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

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

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]

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

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

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

Источник

def result(): HashMap[K, V]

Источник

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

Источник

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

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

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

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

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

Источник

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

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

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

Источник

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

Source

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

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

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

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

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

Пример:

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

Source

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

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

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

Source

def sizeCompare(otherSize: Int): Int

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

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

Source

final def sizeHint(coll: IterableOnce[_], delta: Int): Unit

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

Source

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

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

Источник@inline

final def sizeIs: SizeCompareOps

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

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

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Исходный код

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

Исходный код

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

Суммирует элементы этой коллекции.

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

Исходный код

def tail: HashMap[K, V]

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

Исходный код

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

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

Исходный код

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

Исходный код

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

Коллекция, содержащая последние n элементов этой коллекции.

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

Исходный код

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

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

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

Source

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

Source

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

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

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

Source

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

Преобразование коллекции в массив.

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[(K, V)]

Source

def toList: List[(K, V)]

Source

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

Source

def toSeq: Seq[(K, V)]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[(K, V)]

Source

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

Транспонирует это итерируемое множество итерируемых множеств в итерируемое множество итерируемых множеств.

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

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

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

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

Source

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

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

Source

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

Source

override def unzip3[A1, A2, A3](implicit asTriple: (K, V) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

Source

def values: Iterable[V]

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

Source

override def view: MapView[K, V]

Source

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

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

Исходный код

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