Класс BitSet.BitSet1

class BitSet1(val elems: Long) extends BitSet

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

Исходный код

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

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

Исходный код

override def filterImpl(pred: Int => Boolean, isFlipped: Boolean): BitSet

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

Исходный код

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

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

Исходный код

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

Добавляет все элементы этого набора в 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

Добавляет все элементы этого набора в 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 bitSetFactory: SpecificIterableFactory[Int, BitSet]

Исходный код

def canEqual(that: Any): Boolean

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

Источник

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

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

Источник

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

Источник

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 drop(n: Int): C

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

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

Источник

override def dropRight(n: Int): C

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

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

Источник

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

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

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

Источник

override def empty: BitSet

Пустой итерируемый набор того же типа, что и этот итерируемый набор.

Источник

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 excl(elem: Int): BitSet

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

Источник

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])(implicit ev: Ordering[B]): SortedSet[B]

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

Источник

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

Источник

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 incl(elem: Int): BitSet

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

Источник

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)(implicit ev: Ordering[B]): SortedSet[B]

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

Источник

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

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

Источник

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)

Source

override def size: Int

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

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

Source

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

Сравнивает размер этой итерируемой коллекции с размером другой Iterable.

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

Source

def sizeCompare(otherSize: Int): Int

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

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

Source

final def sizeIs: SizeCompareOps

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

Эти операции реализованы с помощью sizeCompare(Int) и позволяют использовать следующие более удобочитаемые выражения:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Source

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

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

from <= indexOf(x) < until

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

Source

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

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

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

Source

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

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

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

Source

override def sortedIterableFactory: SortedIterableFactory[SortedSet]

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

Source

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

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

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

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

Source

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

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

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

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

Источник

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 можно преобразовать только в последовательные потоки.

Источник

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

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

Источник

def subsets(): Iterator[C]

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

Источник

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

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

Источник

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

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

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Источник

def take(n: Int): C

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

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

Источник

override def takeRight(n: Int): C

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

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

Источник

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

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

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

Источник

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]

Source

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

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

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

Source

def toBitMask: Array[Long]

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

Source

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

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

override def toString(): String

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

По умолчанию представление зависит от платформы.

Source

def toVector: Vector[A]

Source

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

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

Source

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

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

Source

override def unsorted: Set[Int]

Source

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

Source

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])(implicit ev: Ordering[(Int, B)]): SortedSet[(Int, B)]

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

Источник

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

Конкретные поля

Источник

val elems: Long