Трейт scala.collection.BitSet

трейт BitSet extends SortedSet[Int] with BitSetOps[BitSet]

Базовый тип битовых множеств.

Этот трейт предоставляет большинство операций над битовыми множествами BitSet независимо от его представления. Он наследуется всеми конкретными реализациями битовых множеств.

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

Исходный код

override def empty: BitSet

Исходный код

override def unsorted: Set[Int]

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

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

final def &(that: Set[Int]): BitSet

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

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

final def &~(that: Set[Int]): BitSet

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

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

final def ++(that: IterableOnce[Int]): BitSet

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

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

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

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

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

final def ^(other: BitSet): BitSet

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

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

Source@inline

final def apply(elem: Int): Boolean

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

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

Source

def bitSetFactory: SpecificIterableFactory[Int, BitSet]

Source

def canEqual(that: Any): Boolean

Source

def collect(pf: PartialFunction[Int, Int]): BitSet

Source

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

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

Source

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

Source

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

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

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

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

Source@unspecialized

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

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

Source

override def concat(other: IterableOnce[Int]): BitSet

Source

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

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

Source

def contains(elem: Int): Boolean

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

def diff(other: Set[Int]): BitSet

Source

def drop(n: Int): BitSet

Source

def dropRight(n: Int): BitSet

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

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

Source

def dropWhile(p: Int => Boolean): BitSet

Источник

override def equals(that: Any): Boolean

Источник

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

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

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

Источник

def filter(pred: Int => Boolean): BitSet

Источник

def filterNot(pred: Int => Boolean): BitSet

Источник

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

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

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

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

Источник

def firstKey: Int

Источник

def flatMap(f: Int => IterableOnce[Int]): BitSet

Источник

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

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

Источник

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

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

Исходный код

override def hashCode(): Int

Исходный код

def head: Int

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

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

Исходный код

def headOption: Option[Int]

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

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

Исходный код

def init: BitSet

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

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

Исходный код

def inits: Iterator[BitSet]

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

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

Исходный код

override def intersect(other: Set[Int]): BitSet

Исходный код

override def isEmpty: Boolean

Исходный код

override def isTraversableAgain: Boolean

Исходный код

override def iterableFactory: IterableFactory[Set]

Исходный код

def iterator: Iterator[Int]

Исходный код

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

Исходный код

def knownSize: Int

Исходный код

def last: Int

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

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

Исходный код

def lastKey: Int

Исходный код

def lastOption: Option[Int]

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

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

Исходный код

def lazyZip[B](that: Iterable[B]): LazyZip2[Int, B, BitSet]

Аналогично 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(f: Int => Int): BitSet

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

Источник

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

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

Источник

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

Источник

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@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

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

Источник

final def ordering: Ordering[Int]

Источник

override def partition(p: Int => Boolean): (BitSet, BitSet)

Источник

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

Источник

def product[B >: Int](implicit num: Numeric[B]): B

Перемножает элементы этого набора.

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

Источник

def range(from: Int, until: Int): BitSet

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

Источник

def rangeFrom(from: Int): BitSet

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

Источник

def rangeImpl(from: Option[Int], until: Option[Int]): BitSet

Источник

def rangeTo(to: Int): BitSet

Источник

def rangeUntil(until: Int): BitSet

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

protected def reversed: Iterable[Int]

Source

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

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

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

Source

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

Source

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

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

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

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

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

Пример:

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

Source

override def size: Int

Source

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

Source

def sizeCompare(otherSize: Int): Int

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

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Source@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

Source

def slice(from: Int, until: Int): BitSet

Source

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

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

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

Source

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

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

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

Source

def sortedIterableFactory: SortedIterableFactory[SortedSet]

Source

def span(p: Int => Boolean): (BitSet, BitSet)

Source

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

Source

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S & EfficientSplit

Source

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

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

Source

def subsets(): Iterator[BitSet]

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

Source

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

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

Source

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

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

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

Исходный код

def tail: BitSet

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

Исходный код

def tails: Iterator[BitSet]

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

Исходный код

def take(n: Int): BitSet

Исходный код

def takeRight(n: Int): BitSet

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

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

Исходный код

def takeWhile(p: Int => Boolean): BitSet

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

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

Исходный код

override def tapEach[U](f: Int => U): BitSet

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def toBitMask: Array[Long]

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

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

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

Исходный код

def toIndexedSeq: IndexedSeq[Int]

Исходный код

def toList: List[Int]

Исходный код

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

Исходный код

def toSeq: Seq[Int]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[Int]

Исходный код

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

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

Источник

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

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

Источник

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

Источник

def xor(other: BitSet): BitSet

Вычисляет симметрическую разность этого битового набора и другого битового набора, выполняя побитовое «исключающее ИЛИ».

Источник

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

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

Источник

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

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

Источник

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

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

Источник

def zipWithIndex: Set[(Int, Int)]

Источник@inline

final def |(that: Set[Int]): BitSet

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