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

protected class ImmutableKeySet extends AbstractSet[K] with DefaultSerializable

Реализующий класс множества, возвращаемого keySet

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

Исходный код

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

Исходный код

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

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

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

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

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

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

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

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

Исходный код

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

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

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

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

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

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

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

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

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

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

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

Исходный код

final override def --(that: IterableOnce[K]): Set[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]): Set[B]

Источник

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

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

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

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

Источник@unspecialized

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

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

Источник

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

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

Источник

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

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

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

Пример:

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

Источник

def contains(key: K): Boolean

Источник

def copyToArray[B >: K](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 >: K](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 >: K](xs: Array[B]): Int

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

Источник

override def empty: Set[K]

Источник

override def equals(that: Any): Boolean

Равенство множеств реализовано с помощью метода поиска contains. Этот метод возвращает true, если

• аргумент that является Set,

• два множества имеют одинаковый размер, и

• для каждого element этого множества, other.contains(element) == true.

Реализация equals проверяет метод canEqual, поэтому подклассы Set могут сузить равенство до определенных типов множеств. Реализации Set в стандартной библиотеке могут все сравниваться, их методы canEqual возвращают true.

Примечание: метод equals соблюдает законы равенства (симметрия, транзитивность) только в том случае, если два множества используют ту же функцию эквивалентности элементов в своей операции поиска. Например, операция эквивалентности элементов в scala.collection.immutable.TreeSet определяется его порядком. Сравнение TreeSet с HashSet приводит к неожиданным результатам, если ordering.equiv(e1, e2) (используемая для поиска в TreeSet ) отличается от e1 == e2 (используемая для поиска в HashSet).

scala> import scala.collection.immutable._
scala> val ord: Ordering[String] = _ compareToIgnoreCase _

scala> TreeSet("A")(ord) == HashSet("a")
val res0: Boolean = false

scala> HashSet("a") == TreeSet("A")(ord)
val res1: Boolean = true

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

Источник

def flatten[B](implicit asIterable: K => IterableOnce[B]): Множество[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.

Источник

protected def fromSpecific(coll: IterableOnce[K]): Множество[K]

Источник

def groupBy[K](f: K => K): Map[K, Множество[K]]

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

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

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

Источник

def groupMap[K, B](key: K => K)(f: K => B): Map[K, Множество[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: Целое): Итератор[Множество[K]]

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

Исходный код

override def hashCode(): Int

Исходный код

def head: K

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

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

Исходный код

def headOption: Option[K]

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

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

Исходный код

def init: Set[K]

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

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

Исходный код

def inits: Iterator[Set[K]]

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

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

Исходный код

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

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

Исходный код

override def isEmpty: Boolean

Исходный код

override def isTraversableAgain: Boolean

Исходный код

override def iterableFactory: IterableFactory[Set]

Исходный код

def iterator: Iterator[K]

Исходный код

override def knownSize: Int

Исходный код

def last: K

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

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

Исходный код

def lastOption: Option[K]

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

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

Исходный код

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

Аналогично 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)

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код@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, который можно переопределить.

Источник

protected def newSpecificBuilder: Builder[K, Набор[K]]

Источник@deprecatedOverriding("nonEmpty определен как !isEmpty; переопределите isEmpty вместо этого", "2.13.0")

def nonEmpty: Boolean

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

Источник

def partition(p: K => Boolean): (Набор[K], Набор[K])

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

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

Источник

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

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

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

Источник

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

Сравнивает размер этого итерируемого набора с размером другого набора.

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

Источник

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

override def splitAt(n: Int): (Set[K], Set[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. Для Steppers, помеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Steppers могут быть преобразованы только в последовательные потоки.

Исходный код

def subsetOf(that: Set[K]): Boolean

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

def tail: Set[K]

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

Исходный код

def tails: Iterator[Set[K]]

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

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

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

Исходный код

def toIndexedSeq: IndexedSeq[K]

Исходный код

def toList: List[K]

Исходный код

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

Исходный код

def toSeq: Seq[K]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[K]

Исходный код

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

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

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

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

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

Исходный код

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

Исходный код

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

Исходный код

def view: View[K]

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

Исходный код

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

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

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

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

Исходный код

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

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