Класс scala.collection.immutable.ImmutableKeySortedSet

protected class ImmutableKeySortedSet extends AbstractSet[K] with SortedSet[K]

Класс-реализация множества, возвращаемого keySet

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

Исходный код

def excl(elem: K): SortedSet[K]

Исходный код

def incl(elem: K): SortedSet[K]

Исходный код

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

Наследуемые методы

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

final def &(that: Set[K]): SortedSet[K]

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

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

final def &~(that: Set[K]): SortedSet[K]

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

Исходный код

final override def +(elem: K): SortedSet[K]

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

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

final def ++(that: IterableOnce[K]): SortedSet[K]

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

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

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

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

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

final override def -(elem: K): SortedSet[K]

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

Исходный код

final override def --(that: IterableOnce[K]): SortedSet[K]

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

Исходный код@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): K => A

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

Источник@inline

final def apply(elem: K): Boolean

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

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

Источник

def canEqual(that: Any): Boolean

Источник

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

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

Источник

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

Источник

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

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

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

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

Источник@unspecialized

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

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

Источник

def concat(that: IterableOnce[K]): SortedSet[K]

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

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

Пример:

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

Источник

def concat[B >: K](suffix: IterableOnce[B]): Set[B]

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

Источник

def contains(key: K): Boolean

Источник

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

def diff(that: Set[K]): SortedSet[K]

Source

def drop(n: Int): SortedSet[K]

Source

def dropRight(n: Int): SortedSet[K]

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

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

Source

def dropWhile(p: K => Boolean): SortedSet[K]

Source

override def empty: SortedSet[K]

Source

override def equals(that: Any): Boolean

Source

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

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

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

Source

def filter(pred: K => Boolean): SortedSet[K]

Source

def filterNot(pred: K => Boolean): SortedSet[K]

Source

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

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

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

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

Источник

def firstKey: K

Источник

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

override protected def fromSpecific(coll: IterableOnce[K]): SortedSet[K]

Источник

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

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

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

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

Источник

def groupMap[K, B](key: K => K)(f: K => 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: K => K)(f: K => 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[SortedSet[K]]

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

Источник

override def hashCode(): Int

Источник

def head: K

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

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

Источник

def headOption: Option[K]

Возвращает необязательный первый элемент.

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

Источник

def init: SortedSet[K]

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

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

Источник

def inits: Iterator[SortedSet[K]]

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

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

Источник

def intersect(that: Set[K]): SortedSet[K]

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[Set]

Источник

def iterator: Iterator[K]

Источник

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

Источник

override def knownSize: Int

Источник

def last: K

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

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

Источник

def lastKey: K

Source

def lastOption: Option[K]

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

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

Source

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

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

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

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

Source

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

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

Source

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

Source

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

Source

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

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

Source

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

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

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

id="maxByOption-fffff66f"> Источник

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

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

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

id="maxOption-fffff45e"> Источник

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

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

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

id="min-ffffff34"> Источник

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

id="minAfter-fffffb50"> Источник

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

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

id="minBy-fffff0c5"> Источник

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

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

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

Source

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

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

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

Source

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

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

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

Source@inline

final def mkString: String

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

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

Source@inline

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

override protected def newSpecificBuilder: Builder[K, SortedSet[K]]

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Source

def partition(p: K => Boolean): (SortedSet[K], SortedSet[K])

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

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

Source

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

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

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

Source

def range(from: K, until: K): SortedSet[K]

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

Исходный код

def rangeFrom(from: K): SortedSet[K]

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

Исходный код

def rangeTo(to: K): SortedSet[K]

Исходный код

def rangeUntil(until: K): SortedSet[K]

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def removedAll(that: IterableOnce[K]): SortedSet[K]

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

Источник

protected def reversed: Iterable[K]

Источник

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

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

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

Источник

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

Источник

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

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

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

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

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

Пример:

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

Источник

override 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

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

Эти операции реализованы с использованием 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): SortedSet[K]

Источник

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

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

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

Источник

def sliding(size: Int): Iterator[SortedSet[K]]

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

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

Источник

override def sortedIterableFactory: SortedIterableFactory[SortedSet]

Источник

def span(p: K => Boolean): (SortedSet[K], SortedSet[K])

Источник

override def splitAt(n: Int): (SortedSet[K], SortedSet[K])

Источник

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

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

Источник

def subsets(): Iterator[SortedSet[K]]

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

Источник

def subsets(len: Int): Iterator[SortedSet[K]]

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

Источник

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

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

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

Источник

def tail: SortedSet[K]

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

Источник

def tails: Iterator[SortedSet[K]]

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

Источник

def take(n: Int): SortedSet[K]

Источник

def takeRight(n: Int): SortedSet[K]

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

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

Источник

def takeWhile(p: K => Boolean): SortedSet[K]

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

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

Источник

override def tapEach[U](f: K => U): SortedSet[K]

Источник

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

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

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

Источник

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

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

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[K]

Source

def toList: List[K]

Source

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

Source

def toSeq: Seq[K]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[K]

Source

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

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

Source@inline

final def union(that: Set[K]): SortedSet[K]

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

Source

override def unsorted: Set[K]

Source

def unzip[A1, A2](implicit asPair: K => (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))

Source

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

Source

def view: View[K]

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

Source

override def withFilter(p: K => Boolean): WithFilter[K, Set, SortedSet]

Source

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

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

Источник

def zip[B](that: IterableOnce[B]): Set[(K, B)]

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

Источник

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

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

Источник

def zipWithIndex: Set[(K, Int)]

Источник@inline

final def |(that: Set[K]): SortedSet[K]

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

Унаследованные неявные параметры

Источник

implicit def ordering: Ordering[K]