Тракт Map.Map

тракт Map[K, V] extends Iterable[(K, V)] with Map[K, V] with MapOps[K, V, Map, Map[K, V]] with Growable[(K, V)] with Shrinkable[K] with MapFactoryDefaults[K, V, Map, Iterable]

Базовый тип изменяемых карт

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

Исходный код

override def mapFactory: MapFactory[Map]

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

Исходный код

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) не сохранит значение по умолчанию.

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

Исходный код

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

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

Исходный код

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

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

Исходный код

final def ++=(xs: IterableOnce[(K, V)]): Growable.this.type

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

Исходный код

final def +=(elem: (K, V)): Growable.this.type

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

Исходный код

final def --=(xs: IterableOnce[K]): Shrinkable.this.type

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

Исходный код

final def -=(elem: K): Shrinkable.this.type

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

Исходный код

def addAll(xs: IterableOnce[(K, V)]): Growable.this.type

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

Исходный код

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

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

Исходный код

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

Источник

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

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

Пример:

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

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

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

Источник

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

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

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

Источник

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

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

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

Source

def apply(key: K): V

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

Source

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

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

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

if(pf isDefinedAt x) pf(x) else default(x)

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

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерной оценке apply/isDefinedAt - lift и unlift не оценивают исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условным применением действий

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

Source

def canEqual(that: Any): Boolean

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

Source

def clear(): Unit

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

Source

override def clone(): C

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

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

Source

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

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

Source

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

Источник

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

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

Источник

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

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

Источник

def contains(key: K): Boolean

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def default(key: K): V

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

Источник

def drop(n: Int): C

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

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

Источник

def dropRight(n: Int): C

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

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

Источник

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

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

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

Источник

def elementWise: ElementWiseExtractor[A, B]

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

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

Источник

override def empty: CC[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

Source

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

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

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

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

Source

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

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

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Source

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

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

Source

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

Преобразует этот итерируемый набор наборов итерируемых элементов в итерируемый набор, образованный элементами этих наборов итерируемых элементов.

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

def get(key: K): Option[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, C]

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

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

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

Исходный код

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

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

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

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

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

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

Исходный код

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

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

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

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

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

Исходный код

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

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

Источник

override def hashCode(): Int

Вычисляет значение хэш-кода для объекта.

Стандартный алгоритм хэширования зависит от платформы.

Обратите внимание, что для двух объектов могут быть идентичны хэш-коды (o1.hashCode.equals(o2.hashCode)) но не быть равными (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true), то у них идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода, убедитесь, что поведение согласуется с методом equals.

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

def isDefinedAt(key: K): Boolean

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

Источник

def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

override def iterableFactory: IterableFactory[Iterable]

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

Источник

def iterator: Iterator[A]

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

Источник

def keySet: Set[K]

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

Источник

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

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

Источник

def keys: Iterable[K]

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

Источник

def keysIterator: Iterator[K]

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

Источник

override def knownSize: Int

Source

def last: A

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

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

Source

def lastOption: Option[A]

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

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

Source

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

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

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

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

Source

def lift: A => Option[B]

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def mkString: String

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

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

Источник

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

Источник

def nonEmpty: Boolean

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

Источник

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

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

Источник

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

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

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

Источник

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

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

Пример:

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

Удаляет ключ из этой карты, возвращая значение, ранее связанное с этим ключом, как значение Option.

Источник

def result(): C

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

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

Пример:

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

Источник

def size: Int

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

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

Источник

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

Сравнивает размер этой итерируемой коллекции с размером другой 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

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

Источник

def sizeHint(size: Int): Unit

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

Источник

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

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

Источник

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

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

from <= indexOf(x) < until

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

Возвращает scala.collection.Stepper для элементов этого набора.

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

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

• Для наборов типа Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для наборов типа Double или Float, возвращается scala.collection.DoubleStepper

• Для наборов типа Long возвращается scala.collection.LongStepper

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

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

Source

def subtractAll(xs: IterableOnce[K]): Shrinkable.this.type

Удаляет все элементы, сгенерированные итератором, из этого уменьшаемого набора.

Source

def subtractOne(elem: K): Shrinkable.this.type

Удаляет один элемент из этого уменьшаемого набора.

Source

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

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

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

Source

def tail: C

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

Source

def tails: Iterator[C]

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

Source

def take(n: Int): C

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

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

Source

def takeRight(n: Int): C

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

Преобразует набор в массив.

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

Source

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

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

override def toString(): String

Возвращает строковое представление объекта.

Стандартное представление зависит от платформы.

Source

def toVector: Vector[A]

Source

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

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

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

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

Source

def values: Iterable[V]

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

Source

def valuesIterator: Iterator[V]

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

Source

override def view: MapView[K, V]

Представление элементов этого набора.

Source

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

Создаёт нестрогий фильтр этой карты.

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

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

Исходный код

def zip[B](that: IterableOnce[B]): CC[(A, B)]

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

Исходный код

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

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

Исходный код

def zipWithIndex: CC[(A, Int)]

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