Класс BitSet.BitSet

sealed abstract class BitSet extends AbstractSet[Int] with SortedSet[Int] with SortedSetOps[Int, SortedSet, BitSet] with StrictOptimizedSortedSetOps[Int, SortedSet, BitSet] with BitSet with BitSetOps[BitSet] with Serializable

Класс для неизменяемых битовых множеств.

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

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

Исходный код

def bitSetFactory: SpecificIterableFactory[Int, BitSet]

Исходный код

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

Исходный код

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

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

Исходный код

override def empty: BitSet

Пустая итерируемая коллекция того же типа, что и эта итерируемая коллекция.

Исходный код

def excl(elem: Int): BitSet

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

Исходный код

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

Исходный код

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

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

Исходный код

def incl(elem: Int): BitSet

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

Исходный код

override def map(f: Int => Int): BitSet

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

Исходный код

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

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

Исходный код

override def unsorted: Set[Int]

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

final override def +(elem: Int): C

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

Исходный код

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

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

Исходный код

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

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

Исходный код

final override def -(elem: Int): C

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

Исходный код

final override def --(that: IterableOnce[Int]): C

Псевдоним для удаления всех

Исходный код

final def ^(other: BitSet): C

Исходный код

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

Исходный код

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)

Исходный код

def andThen[A](g: Boolean => A): T1 => A

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

Исходный код

final def apply(elem: Int): Boolean

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

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

Исходный код

def canEqual(that: Any): Boolean

Метод, который должен вызываться из каждого хорошо спроектированного метода equals, открытого для переопределения в подклассе. См. Программирование на Scala, глава 28 для обсуждения и проектирования.

Исходный код

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

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

Исходный код

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

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

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

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

Исходный код

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

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

Исходный код

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

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

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

Пример:

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

Исходный код

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

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

Исходный код

def contains(elem: Int): Boolean

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Источник

def drop(n: Int): C

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

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

Исходный код

override def dropRight(n: Int): C

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

override def filter(pred: Int => Boolean): C

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

Источник

override def filterNot(pred: Int => Boolean): C

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

Источник

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

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

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

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

Источник

def firstKey: A

Возвращает первый ключ набора.

Источник

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующего набора определяется статическим типом итерируемого набора. Это может иногда приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Источник

override def flatten[B](implicit toIterableOnce: Int => IterableOnce[B]): CC[B]

Преобразует этот итерируемый набор наборов перебираемых элементов в итерируемый набор, образованный элементами этих наборов перебираемых элементов.

Тип результирующего набора будет определяться типом итерируемого набора. Например:

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

Источник

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

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

Источник

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

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

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

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

Источник

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

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

Источник

override def hashCode(): Int

Вычисляет значение хэш-кода для объекта.

Алгоритм хэширования по умолчанию зависит от платформы.

Обратите внимание, что допускается, что два объекта имеют одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)), но при этом не являются равными (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true), у них были идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода убедитесь, что поведение согласуется с методом equals.

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

Проверяет, можно ли многократно проходить по этому итерируемому набору. Всегда истинно для Iterables и ложно для Iterators, если не переопределено.

Источник

override def iterableFactory: IterableFactory[Set]

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

Источник

def iterator: Iterator[Int]

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

Источник

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

Создает итератор, содержащий все значения из этой коллекции, большие или равные start в соответствии с порядком этой коллекции. x.iteratorFrom(y) эквивалентно, но обычно эффективнее, чем x.from(y).iterator

Источник

def knownSize: Int

Источник

def last: A

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

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

Источник

def lastKey: A

Возвращает последний ключ коллекции.

Источник

def lastOption: Option[A]

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

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

final def mkString: String

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

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

Источник

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

def nonEmpty: Boolean

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

Источник

final def ordering: Ordering[Int]

Источник

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

Возвращает пару: первый элемент, удовлетворяющий предикату p, и второй элемент, не удовлетворяющий. Интересно, поскольку разбивает коллекцию на две части.

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

Источник

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

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

Источник

def rangeFrom(from: Int): C

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

Источник

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

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

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

Источник

def rangeTo(to: Int): C

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

Источник

def rangeUntil(until: Int): C

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

Источник

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

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

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

Источник

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

def removedAll(that: IterableOnce[Int]): C

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

Исходный код

protected def reversed: Iterable[A]

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

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

Пример:

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

Исходный код

override def size: Int

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

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

Исходный код

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

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

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

Исходный код

def sizeCompare(otherSize: Int): Int

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

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

Исходный код

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

Выбирает интервал элементов. Полученный итерируемый набор состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

override def sortedIterableFactory: SortedIterableFactory[SortedSet]

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

Исходный код

override def span(p: Int => Boolean): (C, C)

Разделяет этот итерируемый набор на пару префикс/суффикс в соответствии с предикатом.

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

Исходный код

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

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Source

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

Возвращает scala.collection.Stepper для элементов этого набора.

Stepper позволяет создавать Java-поток для работы с коллекцией, см. scala.jdk.StreamConverters. Для коллекций, содержащих примитивные значения, Stepper можно использовать в качестве итератора, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип возвращаемого Stepper в соответствии с типом элементов этой коллекции.

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

• Для любого другого типа элементов возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределен в подклассах, а тип возвращаемого значения уточняется до S with EfficientSplit, например, scala.collection.IndexedSeqOps.stepper. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Stepper могут быть преобразованы только в последовательные потоки.

Source

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

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

Source

def subsets(): Iterator[C]

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

Source

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

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

Source

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

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

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

Source

def tail: C

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

Source

def tails: Iterator[C]

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

Source

def take(n: Int): C

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

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

Source

override def takeRight(n: Int): C

Коллекция, содержащая последние n элементов этой коллекции.

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

Source

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

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

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

Source

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

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

Source

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]

Создает маску битов для этого набора в виде нового массива длинных целых чисел

Исходный код

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

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

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString(): String

Возвращает строковое представление объекта.

Стандартное представление зависит от платформы.

Исходный код

def toVector: Vector[A]

Исходный код

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

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

Исходный код

final def union(that: Set[Int]): C

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

Исходный код

override def unzip[A1, A2](implicit asPair: Int => (A1, A2)): (CC[A1], CC[A2])

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

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

Исходный код

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

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

Исходный код

override def withFilter(p: Int => Boolean): WithFilter[A, WithFilterCC, CC]

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

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

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

Источник

def xor(other: BitSet): C

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

Источник

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

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

Источник

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

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

Источник

override def zipWithIndex: CC[(A, Int)]

Объединяет эту итерируемую коллекцию с ее индексами.

Источник

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

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