Особенность StrictOptimizedSortedMapOps.StrictOptimizedSortedMapOps

trait StrictOptimizedSortedMapOps[K, +V, +CC <: ([X, Y] =>> Map[X, Y] & SortedMapOps[X, Y, CC, _]), +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C] with StrictOptimizedMapOps[K, V, Map, C]

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

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

Исходный код

override def collect[K2, V2](pf: PartialFunction[(K, V), (K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2]

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

Source

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

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

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

Source

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

Источник

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

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

Источник

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

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

Источник

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.

Source

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

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

Source

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

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

Source

def contains(key: K): Boolean

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

Source

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

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

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

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

Source

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

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

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

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

Source

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.

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

Источник

override 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
}

Исходный код

def empty: C

Пустой итерируемый набор того же типа, что и этот итерируемый набор

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

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

Исходный код

def firstKey: K

Возвращает первый ключ набора.

Исходный код

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

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

Исходный код

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

Исходный код

override def flatten[B](implicit toIterableOnce: ((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

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

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

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

Source

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

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

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

Source

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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]

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

def isDefinedAt(key: K): Boolean

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

Источник

def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

def iterableFactory: IterableFactory[CC]

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

Источник

def iterator: Iterator[A]

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

Источник

def iteratorFrom(start: K): Iterator[(K, V)]

Создает итератор по всем парам ключ/значение, содержащимся в этой карте, имеющим ключ, больший или равный start, в соответствии с порядком этой карты. x.iteratorFrom(y) эквивалентно, но часто более эффективно, чем x.from(y).iterator.

Источник

override def keySet: SortedSet[K]

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

Источник

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

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

Источник

def keys: Iterable[K]

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

Источник

def keysIterator: Iterator[K]

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

Source

def keysIteratorFrom(start: K): Iterator[K]

Создаёт итератор по всем ключам (или элементам), содержащимся в этом наборе, большим или равным start согласно порядку этого набора. x.keysIteratorFrom(y) эквивалентно, но часто эффективнее, чем x.from(y).keysIterator.

Source

def knownSize: Int

Source

def last: A

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

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

Source

def lastKey: K

Возвращает последний ключ коллекции.

Source

def lastOption: Option[A]

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

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

Source

def lift: A => Option[B]

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

Source

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

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

Source

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

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

Source

def mapFactory: MapFactory[CC]

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

Source

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

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

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

Source

def maxBefore(key: K): Option[(K, V)]

Находит элемент с наибольшим ключом, меньшим заданного ключа.

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 minAfter(key: K): Option[(K, V)]

Находит элемент с наименьшим ключом, большим или равным заданному ключу.

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]

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

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

Источник

final def mkString: String

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

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

Источник

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

def nonEmpty: Boolean

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

Источник

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

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

Источник

def ordering: Ordering[A]

Источник

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

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

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

Источник

override 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 range(from: K, until: K): C

Создаёт проектирование диапазона этой коллекции с нижней и верхней границами.

Источник

def rangeFrom(from: K): C

Создаёт проектирование диапазона этой коллекции без верхней границы.

Источник

def rangeImpl(from: Option[K], until: Option[K]): C

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

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

Источник

def rangeTo(to: K): C

Создаёт проектирование диапазона этой коллекции без нижней границы.

Источник

def rangeUntil(until: K): C

Создаёт проектирование диапазона этой коллекции без нижней границы.

Источник

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]

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

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

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

Источник

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

Источник

override 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 sortedMapFactory: SortedMapFactory[CC]

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

Источник

override 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 можно преобразовать только в последовательные потоки.

Исходный код

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

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

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

Исходный код

def tail: C

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

Исходный код

def tails: Iterator[C]

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

Исходный код

def take(n: Int): C

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

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

Исходный код

override def takeRight(n: Int): C

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Источник

def toList: Список[A]

Источник

def toMap[K, V](implicit ev: (K, V) <:< (K, V)): Карта[K, V]

Источник

def toSeq: Последовательность[A]

Источник

def toSet[B >: (K, V)]: Множество[B]

Источник

override def toString(): Строка

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

Значение по умолчанию зависит от платформы.

Источник

def toVector: Вектор[A]

Источник

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

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

Источник

def unapply(a: K): Вариант[B]

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

Источник

def unsorted: Карта[K, V]

Источник

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

Источник

override 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 <: Счётчик[_]](implicit shape: StepperShape[V, S]): S

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

Источник

def values: Итерируемая[V]

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

Источник

def valuesIterator: Итератор[V]

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

Источник

def valuesIteratorFrom(start: K): Итератор[V]

Создаёт итератор по всем значениям, содержащимся в этой карте, связанным с ключом, который больше или равен start в соответствии с порядком этой карты. x.valuesIteratorFrom(y) эквивалентно, но часто более эффективно, чем x.from(y).valuesIterator.

Источник

override def view: MapView[K, V]

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

Source

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

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

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

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

Source

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

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

Source

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

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

Source

override def zipWithIndex: CC[(A, Int)]

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