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

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

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник

final override def --(that: IterableOnce[A]): Set[A]

Псевдоним для 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): A => A

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

Источник@inline

final def apply(elem: A): Boolean

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

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

Источник

def canEqual(that: Any): Boolean

Источник

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

Источник

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

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

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

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

Источник@unspecialized

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

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

Источник

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

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

Источник

def concat(that: IterableOnce[A]): Set[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: Array[B], start: Int, len: Int): Int

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

Source

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

Source

override def empty: Set[A]

Source

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

Source

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

Source

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

Source

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

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

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

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

Source

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)

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

Source

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)(_ + _)

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

Source

def grouped(size: Int): Iterator[Set[A]]

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

Source

override def hashCode(): Int

Source

def head: A

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

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

Source

def headOption: Option[A]

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

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

Source

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

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

Source

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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]

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

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

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

Источник

def removedAll(that: IterableOnce[A]): Set[A]

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

Источник

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

Источник

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

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

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

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

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

Пример:

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

Источник

def size: Int

Размер этого набора.

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

Источник

def sizeCompare(that: Iterable[_]): Int

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

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

Источник

def sizeCompare(otherSize: Int): Int

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

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

Источник@inline

final def sizeIs: SizeCompareOps

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

Эти операции реализованы с помощью 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[A]

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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 элементов.

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

Source

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

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

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

Source

override def tapEach[U](f: A => U): Множество[A]

Source

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

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

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

Source

def toArray[B >: A : ClassTag]: Массив[B]

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

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

Source@inline

final def toBuffer[B >: A]: Буфер[B]

Source

def toIndexedSeq: ИндексированныйПоследовательность[A]

Source

def toList: Список[A]

Source

def toMap[K, V](implicit ev: A <:< (K, V)): Карта[K, V]

Source

def toSeq: Последовательность[A]

Source

def toSet[B >: A]: Множество[B]

Source

override def toString(): Строка

Source

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

Source

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

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

Source@inline

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

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

Source

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

Source

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

Source

def view: View[A]

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

Source

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

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

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

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

Source

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

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

Source

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

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

Source

def zipWithIndex: Set[(A, Int)]

Source@inline

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

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