Трейт SeqMap.SeqMap

трейт SeqMap[K, +V] extends Map[K, V] с MapOps[K, V, SeqMap, SeqMap[K, V]] с MapFactoryDefaults[K, V, SeqMap, Iterable]

Общий трейт для упорядоченных карт. Конкретные классы должны предоставить функциональность для абстрактных методов в SeqMap.

Обратите внимание, что при проверке на равенство SeqMap не учитывает порядок.

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

Исходный код

переопределение def mapFactory: MapFactory[SeqMap]

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

Источник

def apply(key: K): V

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

Источник

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

Источник

def canEqual(that: Any): Boolean

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

Источник

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

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

Источник

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

def 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 значениями из этого набора.

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

Source

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

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

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

Source

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

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

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

Source

def default(key: K): V

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

Source

def drop(n: Int): C

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

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

Source

def dropRight(n: Int): C

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

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

Source

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

Источник

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

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

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

Источник

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

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Source

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

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

Source

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

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

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

Source

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

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

Source

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

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

Source

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

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

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

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

Source

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

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

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

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

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

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

Источник

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]

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

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

Source

def init: C

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

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

Source

def inits: Iterator[C]

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

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

Source

def isDefinedAt(key: K): Boolean

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

Source

def isEmpty: Boolean

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

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

Source

override def isTraversableAgain: Boolean

Проверяет, можно ли многократно проходить эту итерируемую коллекцию. Всегда истинно для Iterable и ложно для Iterator, если не переопределено.

Source

def iterableFactory: IterableFactory[Iterable]

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

Source

def iterator: Iterator[A]

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

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

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

final def mkString: String

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

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

Исходный код

final def mkString(sep: String): String

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

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

Исходный код

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

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

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

Исходный код

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]

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

Source

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

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

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

Source

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

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

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

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

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

Source

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

Возвращает результат применения бинарного оператора ко всем элементам этой коллекции слева направо.

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

Возвращает результат применения бинарного оператора ко всем элементам этой коллекции справа налево.

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

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

Источник

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

Источник

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

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

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Источник

def take(n: Int): C

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

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

Источник

def takeRight(n: Int): C

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

Источник

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

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

Источник

def values: Iterable[V]

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

Источник

def valuesIterator: Iterator[V]

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

Источник

override def view: MapView[K, V]

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

Источник

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

Объединяет этот итерируемый набор с его индексами.