Тракт StrictOptimizedSortedSetOps.StrictOptimizedSortedSetOps

тракт StrictOptimizedSortedSetOps[A, +CC <: (SortedSet), +C <: SortedSetOps[A, CC, C]] extends SortedSetOps[A, CC, C] with StrictOptimizedSetOps[A, Set, C]

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

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

Исходный код

переопределение def collect[B](pf: PartialFunction[A, B])(implicit ev: Ordering[B]): CC[B]

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

Исходный код

переопределение def flatMap[B](f: A => IterableOnce[B])(implicit ev: Ordering[B]): CC[B]

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

Исходный код

переопределение def map[B](f: A => B)(implicit ev: Ordering[B]): CC[B]

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

Исходный код

переопределение def zip[B](that: IterableOnce[B])(implicit ev: Ordering[(A, B)]): CC[(A, B)]

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

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

Исходный код

финальное def &(that: Set[A]): C

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

Исходный код

финальное def &~(that: Set[A]): C

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

Исходный код

финальное def ++[B >: A](suffix: IterableOnce[B]): CC[B]

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

Исходный код

финальное def ++(that: IterableOnce[A]): C

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

Исходный код

финальное 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

Исходный код

финальное def addString(b: StringBuilder, sep: String): StringBuilder

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

Пример:

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

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

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

Source

def addString(b: 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[A](g: Boolean => A): T1 => A

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

Source

final def apply(elem: A): Boolean

Проверяет, содержится ли некоторый элемент в этом множестве.

Этот метод эквивалентен contains. Он позволяет множествам интерпретироваться как предикаты.

Source

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

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

Source

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

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

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

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

Source

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

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

Исходный код

override def concat(that: IterableOnce[A]): C

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

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

Пример:

scala> val a = Set(1, 2) concat Set(2, 3)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

Исходный код

def concat[B >: A](suffix: IterableOnce[B]): CC[B]

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

Исходный код

def contains(elem: A): Boolean

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

def copyToArray[B >: A](xs: Array[B]): Int

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

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

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

Источник

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

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

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

Источник

def count(p: A => Boolean): Int

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

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

Источник

def diff(that: Set[A]): C

Вычисляет разность этого набора и другого набора.

Источник

def drop(n: Int): C

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

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

Источник

override def dropRight(n: Int): C

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

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

Источник

def dropWhile(p: A => Boolean): C

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

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

Источник

def empty: C

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

Источник

def exists(p: A => Boolean): Boolean

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

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

Источник

override def filter(pred: A => Boolean): C

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

Источник

override def filterNot(pred: A => Boolean): C

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

Источник

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

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

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

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

Источник

def firstKey: A

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

Источник

override def flatMap[B](f: A => 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: A => 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)

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def forall(p: A => Boolean): Boolean

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

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

Источник

def foreach[U](f: A => U): Unit

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

Источник

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

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

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

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

Исходный код

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

Вычисляет пересечение этого множества и другого множества.

Исходный код

def isEmpty: Boolean

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

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

Исходный код

override def isTraversableAgain: Boolean

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

Исходный код

def iterableFactory: IterableFactory[CC]

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

Исходный код

def iterator: Iterator[A]

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

Исходный код

def iteratorFrom(start: A): Iterator[A]

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

Источник

def knownSize: Int

Источник

def last: A

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

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

Источник

def lastKey: A

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

Источник

def lastOption: Option[A]

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

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

Источник

override def map[B](f: A => B): CC[B]

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

Источник

override def max[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

def maxBefore(key: A): Option[A]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

override def min[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

def minAfter(key: A): Option[A]

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def mkString: String

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

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

Source

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

def nonEmpty: Boolean

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

Source

def ordering: Ordering[A]

Source

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

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

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

Source

override def partitionMap[A1, A2](f: A => 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 >: A](implicit num: Numeric[B]): B

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

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

Источник

def range(from: A, until: A): C

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

Источник

def rangeFrom(from: A): C

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

Источник

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

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

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

Источник

def rangeTo(to: A): C

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

Источник

def rangeUntil(until: A): C

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

Источник

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

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

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

Источник

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

protected def reversed: Iterable[A]

Исходный код

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

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

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

Исходный код

override def scanLeft[B](z: B)(op: (B, A) => B): CC[B]

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

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

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

Исходный код

def scanRight[B](z: B)(op: (A, 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.)

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

Source

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

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

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

Source

def sortedIterableFactory: SortedIterableFactory[CC]

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

Source

override def span(p: A => Boolean): (C, C)

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

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

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

Source

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

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

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

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

Source

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, 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 subsetOf(that: Set[A]): Boolean

Проверяет, является ли это множество подмножеством другого множества.

Источник

def subsets(): Iterator[C]

Итератор по всем подмножествам этого множества.

Источник

def subsets(len: Int): Iterator[C]

Итератор по всем подмножествам этого множества заданного размера. Если запрашиваемый размер невозможен, возвращается пустой итератор.

Источник

def sum[B >: A](implicit num: Numeric[B]): B

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

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Source

def take(n: Int): C

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

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

Source

override def takeRight(n: Int): C

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

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

Source

def takeWhile(p: A => Boolean): C

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

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

Source

override def tapEach[U](f: A => U): C

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

Source

def to[C1](factory: Factory[A, C1]): C1

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

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

Source

def toArray[B >: A : ClassTag]: Array[B]

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

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

Source

final def toBuffer[B >: A]: Buffer[B]

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

def toSet[B >: A]: Set[B]

Source

override def toString(): String

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

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

Source

def toVector: Vector[A]

Source

def transpose[B](implicit asIterable: A => 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

final def union(that: Set[A]): C

Вычисляет объединение между набором и другим набором.

Источник

def unsorted: Множество[A]

Источник

override def unzip[A1, A2](implicit asPair: A => (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: A => (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 view: Просмотр[A]

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

Источник

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

Создает нестрогий фильтр этого итерируемого множества.

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

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

Источник

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

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

Источник

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

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

Источник

override def zipWithIndex: CC[(A, Целое)]

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

Источник

final def |(that: Множество[A]): C

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