Трейт scala.collection.SortedSetOps

трейт SortedSetOps[A, +CC <: (SortedSet), +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] with SortedOps[A, C]

Абстрактные методы

Источник

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

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

Источник

def sortedIterableFactory: SortedIterableFactory[CC]

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

Источник

def unsorted: Set[A]

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

Источник

def collect[B](pf: PartialFunction[A, B])(implicit @implicitNotFound ev: Ordering[B]): CC[B]

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

Источник

def firstKey: A

Источник

def flatMap[B](f: A => IterableOnce[B])(implicit @implicitNotFound ev: Ordering[B]): CC[B]

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

Источник

def lastKey: A

Источник

def map[B](f: A => B)(implicit @implicitNotFound ev: Ordering[B]): CC[B]

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

Источник

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

Источник

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

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

Источник

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

Источник

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

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

Источник

def rangeTo(to: A): C

Источник

def zip[B](that: IterableOnce[B])(implicit @implicitNotFound ev: Ordering[(A, B)]): CC[(A, B)]

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

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

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

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

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

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

final def &~(that: Set[A]): C

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

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

final def ++(that: IterableOnce[A]): C

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

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

final def ++[B >: A](suffix: IterableOnce[B]): Set[B]

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

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

final def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

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

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

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

Пример:

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

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

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

Исходный код

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)

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

def andThen[A](g: Boolean => A): A => A

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

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

final def apply(elem: A): Boolean

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

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

Исходный код

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

Исходный код

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

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

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

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

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

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

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

Исходный код

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]): Set[B]

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

Исходный код

def contains(elem: A): Boolean

Исходный код

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

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

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

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

Исходный код@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Исходный код@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

Исходный код

def dropRight(n: Int): C

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

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

Исходный код

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

Исходный код

def empty: C

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

def flatMap[B](f: A => IterableOnce[B]): Set[B]

Источник

def flatten[B](implicit asIterable: A => IterableOnce[B]): Set[B]

Источник

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, Set[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

Исходный код

def iterableFactory: IterableFactory[Set]

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

Исходный код

def iterator: Iterator[A]

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

Исходный код

def knownSize: Int

Исходный код

def last: A

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

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

Исходный код

def lastOption: Option[A]

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

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

Исходный код

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

Source

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

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

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

Source

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

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

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

Source

def maxOption[B >: A](implicit ord: Ordering[B]): 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]

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Источник

def ordering: Ordering[A]

Source

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

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

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

Source

def partitionMap[A1, A2](f: A => Either[A1, A2]): (Set[A1], Set[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

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

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

Source

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

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

Source

def rangeFrom(from: A): C

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

Source

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

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

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

Source

def rangeUntil(until: A): C

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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): Set[B]

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

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

Источник

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

Источник

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

Источник@inline

final def sizeIs: SizeCompareOps

Возвращает значение типа class, содержащее операции для сравнения размера этой итерируемой коллекции со значением-тестом.

Эти операции реализованы в терминах 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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

Источник

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.

Источник

def take(n: Int): C

Источник

def takeRight(n: Int): C

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

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

Источник

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

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

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

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

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

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

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[A]

Исходный код

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

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

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

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

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

Исходный код

def unzip[A1, A2](implicit asPair: A => (A1, A2)): (Set[A1], Set[A2])

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

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

Исходный код

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (Set[A1], Set[A2], Set[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: View[A]

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

Источник

def withFilter(p: A => Boolean): WithFilter[A, Множество]

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

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

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

Источник

def zip[B](that: IterableOnce[B]): Множество[(A, B)]

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

Источник

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Множество[(A1, B)]

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

Источник

def zipWithIndex: Множество[(A, Целое)]

Источник@inline

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

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