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

class LinkedHashMap[K, V] extends AbstractMap[K, V] with SeqMap[K, V] with MapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, LinkedHashMap[K, V]] with StrictOptimizedMapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]] with MapFactoryDefaults[K, V, LinkedHashMap, Iterable] with DefaultSerializable

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

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

Исходный код

def addOne(kv: (K, V)): LinkedHashMap[K, V]

Исходный код

override def clear(): Unit

Исходный код

override def contains(key: K): Boolean

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

override def head: (K, V)

Исходный код

override def headOption: Option[(K, V)]

Исходный код

override def isEmpty: Boolean

Исходный код

def iterator: Iterator[(K, V)]

Исходный код

override def keySet: Set[K]

Исходный код

override def keysIterator: Iterator[K]

Исходный код

override def knownSize: Int

Исходный код

override def last: (K, V)

Исходный код

override def lastOption: Option[(K, V)]

Исходный код

override def mapFactory: MapFactory[LinkedHashMap]

Источник

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

Источник

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

Источник

override def size: Int

Источник

def subtractOne(key: K): LinkedHashMap[K, V]

Источник

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

Источник

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

Источник

override def valuesIterator: Iterator[V]

Методы-наследники

Источник@inline

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

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

Источник

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник

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

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

Источник@inline

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

Источник@inline

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

Источник

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.

Source

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

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

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

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

def apply(key: K): V

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

Source

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

Source

def canEqual(that: Any): Boolean

Source

override def clone(): LinkedHashMap[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)]): LinkedHashMap[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]

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

Source

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

Source

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

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

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

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

Исходный код@deprecatedOverriding("Это всегда должно передавать управление в 3-аргументную версию этого метода", 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): LinkedHashMap[K, V]

Исходный код

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

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

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

Исходный код

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

Исходный код

def elementWise: ElementWiseExtractor[K, V]

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

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

Исходный код

override def empty: LinkedHashMap[K, V]

Исходный код

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

Источник

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

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

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

Источник

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

Источник

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

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

Источник

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

Источник

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

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

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

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

Источник

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

Источник

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

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

Источник

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

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

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

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

Источник

def groupBy[K](f: (K, V) => K): Map[K, LinkedHashMap[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[LinkedHashMap[K, V]]

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

Источник

override def hashCode(): Int

Источник

def init: LinkedHashMap[K, V]

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

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

Источник

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

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

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

Source

def isDefinedAt(key: K): Boolean

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

Source

override def isTraversableAgain: Boolean

Source

override def iterableFactory: IterableFactory[Iterable]

Source

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

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

Source

def keys: Iterable[K]

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

Source

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

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

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

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

Source

def lift: K => Option[V]

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

Source

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

Source

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

Источник@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): (LinkedHashMap[K, V], LinkedHashMap[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

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

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

Source

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(): LinkedHashMap[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]

Исходный код

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)

Исходный код

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

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

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

Исходный код

def sizeCompare(otherSize: Int): Int

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

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

Исходный код

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

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

Исходный код

def sizeHint(size: Int): Unit

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

Исходный код

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

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

Исходный код@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): LinkedHashMap[K, V]

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

Возвращает scala.collection.Stepper для элементов этой коллекции.

Stepper позволяет создать Java-поток для обработки коллекции, см. scala.jdk.StreamConverters. Для коллекций, содержащих примитивные значения, Stepper может использоваться как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип возвращаемого Stepper в соответствии с типом элемента этой коллекции.

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

• Для любого другого типа элемента возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределяется в дочерних классах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, scala.collection.IndexedSeqOps.stepper. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Stepper могут быть преобразованы только в последовательные потоки.

Исходный код

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

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

Исходный код

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

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

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

Исходный код

def tail: LinkedHashMap[K, V]

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

Исходный код

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

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

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

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

Исходный код

def toIndexedSeq: IndexedSeq[(K, V)]

Исходный код

def toList: List[(K, V)]

Исходный код

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

Исходный код

def toSeq: Seq[(K, V)]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[(K, V)]

Исходный код

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

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

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

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

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

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

Исходный код

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

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

Исходный код

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

Источник

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

Источник

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

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

Источник

def values: Iterable[V]

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

Источник

override def view: MapView[K, V]

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

Источник

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