Класс scala.collection.AbstractSet

абстрактный класс AbstractSet[A] extends AbstractIterable[A] with Set[A]

Явное создание экземпляра Set для уменьшения размера файла класса в подклассах.

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

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

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

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

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

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

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

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

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

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

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

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

Псевдоним для 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 canEqual(that: Any): Boolean

Источник

def collect[B](pf: ЧастичнаяФункция[A, B]): Множество[B]

Источник

def collectFirst[B](pf: ЧастичнаяФункция[A, B]): Некоторые[B]

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

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

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

Источник@unspecialized

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

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

Источник

def concat[B >: A](suffix: IterableOnce[B]): Множество[B]

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

Источник

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

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

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

Пример:

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

Источник

def contains(elem: A): Boolean

Источник

def copyToArray[B >: A](xs: Массив[B], start: Целое, len: Целое): Целое

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

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

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

Источник@deprecatedOverriding("Это всегда должно перенаправлять на 3-аргументную версию этого метода", since = "2.13.4")

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

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

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

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

Источник@deprecatedOverriding("Это всегда должно перенаправлять на 3-аргументную версию этого метода", 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]): Set[A]

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

Исходный код

override def empty: Set[A]

Исходный код

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: A => Boolean): Boolean

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

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

Исходный код

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

Исходный код

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

Исходный код

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.

Исходный код

protected def fromSpecific(coll: IterableOnce[A]): Set[A]

Исходный код

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

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

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

(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[Set[A]]

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

Источник

override def hashCode(): Int

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: Set[A]

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

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

Source

def inits: Iterator[Set[A]]

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

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

Source

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

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

Source

def isEmpty: Boolean

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

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

Source

override def isTraversableAgain: Boolean

Source

override def iterableFactory: IterableFactory[Set]

Source

def iterator: Iterator[A]

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

Source

def knownSize: Int

Source

def last: A

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

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

Source

def lastOption: Option[A]

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, AbstractSet[A]]

Аналогично 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: A => B): Set[B]

Source

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

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

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source@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[A, Set[A]]

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

def nonEmpty: Boolean

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

Источник

def partition(p: A => Boolean): (Set[A], Set[A])

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

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

Источник

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Применяет бинарную операцию ко всем элементам этого набора слева направо.

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

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

Исходный код

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

Необязательно применяет бинарную операцию ко всем элементам этого набора слева направо.

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

Источник

def scanLeft[B](z: B)(op: (B, A) => B): Набор[B]

Источник

def scanRight[B](z: B)(op: (A, B) => B): Набор[B]

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

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

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

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

Пример:

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

Источник

def размер: Целое

Размер этой коллекции.

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

Источник

def sizeCompare(that: Iterable[_]): Целое

Сравнивает размер этой итерируемой коллекции с размером другой 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: Целое): Целое

Сравнивает размер этой итерируемой коллекции со значением-тестом.

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: Целое, until: Целое): Набор[A]

Источник

def sliding(size: Целое, step: Целое): Итератор[Набор[A]]

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

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

Источник

def sliding(size: Целое): Итератор[Набор[A]]

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

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

Источник

def span(p: A => Булево): (Набор[A], Набор[A])

Источник

override def splitAt(n: Целое): (Набор[A], Набор[A])

Источник

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

def tail: Set[A]

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

Исходный код

def tails: Iterator[Set[A]]

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

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

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]: Множество[B]

Источник

override def toString(): String

Источник

def toVector: Вектор[A]

Источник

def transpose[B](implicit asIterable: A => Итерируемый[B]): Множество[Множество[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: Множество[A]): Множество[A]

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

Источник

def unzip[A1, A2](implicit asPair: A => (A1, A2)): (Множество[A1], Множество[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)): (Множество[A1], Множество[A2], Множество[A3])

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

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

Источник

def view: Представление[A]

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

Источник

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

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

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

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

Источник

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

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

Источник

def zipAll[A1 >: A, B](that: Итерируемый[B], thisElem: A1, thatElem: B): Множество[(A1, B)]

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

Источник

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

Источник@inline

final def |(that: Set[A]): Set[A]

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