Трейт scala.collection.mutable.MultiMap

@deprecated("Используйте scala.collection.mutable.MultiDict в модуле scala-collection-contrib", "2.13.0")

trait MultiMap[K, V] extends Map[K, Set[V]]

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

Этот класс обычно используется как миксин. Он преобразует словари, которые отображают K в Set[V] объекты, в многозначные словари, которые отображают K в V объекты.

// first import all necessary types from package `collection.mutable`
import collection.mutable.{ HashMap, MultiMap, Set }
// to create a `MultiMap` the easiest way is to mixin it into a normal
// `Map` instance
val mm = new HashMap[Int, Set[String]] with MultiMap[Int, String]
// to add key-value pairs to a multimap it is important to use
// the method `addBinding` because standard methods like `+` will
// overwrite the complete key-value pair instead of adding the
// value to the existing key
mm.addBinding(1, "a")
mm.addBinding(2, "b")
mm.addBinding(1, "c")
// mm now contains `Map(2 -> Set(b), 1 -> Set(c, a))`
// to check if the multimap contains a value there is method
// `entryExists`, which allows to traverse the including set
mm.entryExists(1, _ == "a") == true
mm.entryExists(1, _ == "b") == false
mm.entryExists(2, _ == "b") == true
// to remove a previous added value there is the method `removeBinding`
mm.removeBinding(1, "a")
mm.entryExists(1, _ == "a") == false

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

Исходный код

def addBinding(key: K, value: V): MultiMap[K, V]

Присваивает указанное value указанному key. Если ключ уже имеет привязку к равно value, ничего не меняется; в противном случае добавляется новая привязка для этого key.

Исходный код

def entryExists(key: K, p: V => Boolean): Boolean

Проверяет, существует ли привязка к key таким образом, что она удовлетворяет предикату p.

Исходный код

protected def makeSet: Set[V]

Создает новый набор.

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

Исходный код

def removeBinding(key: K, value: V): MultiMap[K, V]

Удаляет привязку value к key, если она существует; в противном случае эта операция не оказывает никакого влияния.

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

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

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

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

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

Исходный код

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Исходный код

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

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

Исходный код

def addOne(elem: (K, Set[V])): MultiMap[K, V]

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

Source@inline

final def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

Source@inline

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

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

Пример:

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

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

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

Source

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

Source

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

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

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

Source

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

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

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

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

def apply(key: K): Set[V]

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

Source

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

Source

def canEqual(that: Any): Boolean

Source

def clear(): Unit

Source

override def clone(): Map[K, Set[V]]

Source

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

Source

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

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

Source

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

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

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

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

Источник

def compose[R](k: PartialFunction[R, K]): PartialFunction[R, Множество[V]]

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

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

Источник@unspecialized

def compose[A](g: A => K): A => Множество[V]

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

Источник

def concat[B >: (K, Множество[V])](suffix: IterableOnce[B]): Iterable[B]

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

Источник

def concat[V2 >: Множество[V]](suffix: IterableOnce[(K, V2)]): Map[K, V2]

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

Источник

def contains(key: K): Boolean

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

Источник

def copyToArray[B >: (K, Множество[V])](xs: Массив[B], start: Целое число, len: Целое число): Целое число

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

Заполняет заданный массив 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: Массив[B], start: Целое число): Целое число

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

Заполняет заданный массив 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: Массив[B]): Целое число

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: ((K, Множество[V]), B) => Boolean): Boolean

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

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

Источник

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

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

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

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

def default(key: K): Set[V]

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

Источник

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

Источник

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

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

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

Источник

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

Источник

def elementWise: ElementWiseExtractor[K, Set[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: Map[K, Set[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, Set[V]) => Boolean): Boolean

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

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

Источник

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

Источник

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

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

Источник

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

Источник

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

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

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

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

Исходный код

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

Исходный код

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

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

Исходный код

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

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

Исходный код

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def groupMap[K, B](key: (K, Set[V]) => K)(f: (K, Set[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)

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

Source

def groupMapReduce[K, B](key: (K, Set[V]) => K)(f: (K, Set[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[Map[K, Set[V]]]

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

Source

override def hashCode(): Int

Source

def head: (K, Set[V])

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

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

Source

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

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

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

Source

def init: Map[K, Set[V]]

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

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

Source

def inits: Iterator[Map[K, Set[V]]]

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

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

Source

def isDefinedAt(key: K): Boolean

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

Source

def isEmpty: Boolean

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

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

Source

override def isTraversableAgain: Boolean

Source

override def iterableFactory: IterableFactory[Iterable]

Source

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

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

Source

def keySet: Set[K]

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

Source

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

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

Source

def keys: Iterable[K]

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

Source

def keysIterator: Iterator[K]

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

Source

override def knownSize: Int

Source

def last: (K, Set[V])

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

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

Source

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

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[(K, Set[V]), B, MultiMap[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[Set[V]]

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

Source

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

Source

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

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

Source

override def mapFactory: MapFactory[Map]

Source

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

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

Source

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

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

Source

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

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

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

def nonEmpty: Boolean

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

Source

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

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

Source

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

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

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

Source

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

Применяет функцию f к каждому элементу итерабельной коллекции и возвращает пару итерабельных коллекций: первая содержит значения, возвращаемые f, заключённые в scala.util.Left, а вторая — значения, заключённые в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

Исходный код

def result(): Map[K, Set[V]]

Исходный код

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

Исходный код

def runWith[U](action: Set[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, Set[V])](z: B)(op: (B, B) => B): Iterable[B]

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

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

Исходный код

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

Исходный код

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

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

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

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

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

Пример:

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

Источник

def size: Int

Размер этого набора.

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Source

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

Source

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

Source

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

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

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

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

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

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

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

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

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

Source

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

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

Source

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

Удаляет один элемент из этой уменьшаемой коллекции.

Source

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

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

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

Source

def tail: Map[K, Set[V]]

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

Источник

def tails: Iterator[Map[K, Set[V]]]

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

Источник

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

Преобразовать коллекцию в массив.

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

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

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

Исходный код

def toIndexedSeq: IndexedSeq[(K, Set[V])]

Исходный код

def toList: List[(K, Set[V])]

Исходный код

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

Исходный код

def toSeq: Seq[(K, Set[V])]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[(K, Set[V])]

Исходный код

def transpose[B](implicit asIterable: (K, Set[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[Set[V]]

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def update(key: K, value: Set[V]): Unit

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

def values: Iterable[Набор[V]]

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

Исходный код

def valuesIterator: Итератор[Набор[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, Map]

Исходный код

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

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

Исходный код

def zipWithIndex: Iterable[((K, Набор[V]), Int)]