Класс scala.collection.mutable.BitSet

Тестирование двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для числовых типов возвращает хэш-значение, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## вернёт одинаковое хэш-значение для каждого из них. Для null возвращает хэш-код, где null.hashCode выбрасывает NullPointerException.

Вычисляет пересечение этого набора битов с другим набором битов, выполняя побитовое "и" (AND).

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

Примечание: То же самое, что и intersect.

Обновляет этот набор битов до пересечения с другим набором битов, выполняя побитовое "и" (AND).

Вычисляет разность этого набора битов и другого набора битов, выполняя побитовое "и-не" (AND-NOT).

Разность этого набора и другого набора.

Примечание: То же самое, что и diff.

Обновляет этот набор битов до разности с другим набором битов, выполняя побитовое "и-не" (AND-NOT).

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

Примечание: дубликаты (элементы, для которых equals возвращает true) будут удалены, но не определено, будет ли это элемент этого набора или новый добавленный элемент.

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

Примечание: дубликаты (элементы, для которых equals возвращает true) будут удалены, но не определено, будет ли это элемент этого набора или новый добавленный элемент.

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

Обратите внимание, что дубликаты (элементы, для которых equals возвращает true) будут удалены, но не указано, будет ли это элемент этого множества или вновь добавленный элемент.

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

Как и ++, возвращает новую коллекцию, содержащую элементы из левого операнда, за которыми следуют элементы из правого операнда.

Она отличается от ++ тем, что правый операнд определяет тип результирующей коллекции, а не левый. Мнемоника: двоеточие (COLon) находится со стороны нового типа коллекции (COLlection).

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

Поскольку TraversableOnce не имеет метода ++, нам приходится реализовывать его напрямую, но Traversable и последующие могут использовать перегрузку.

Как и ++, возвращает новую коллекцию, содержащую элементы из левого операнда, за которыми следуют элементы из правого операнда.

Она отличается от ++ тем, что правый операнд определяет тип результирующей коллекции, а не левый. Мнемоника: двоеточие (COLon) находится со стороны нового типа коллекции (COLlection).

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

добавляет все элементы, созданные TraversableOnce, в эту расширяемую коллекцию.

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

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

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

Создаёт новое множество, содержащее все элементы этого множества, за исключением elem.

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

Удаляет все элементы, сгенерированные итератором, из этого изменяемого множества.

Удаляет один элемент из этого битового множества.

Удаляет два или более элементов из этого изменяемого множества.

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

Примечание: /: — это альтернативная запись для foldLeft; z /: xs эквивалентно xs foldLeft z.

Примеры:

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

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

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

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

Примечание: :\ — это альтернативная запись для foldRight; xs :\ z эквивалентно xs foldRight z.

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

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

Примеры:

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

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

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

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

Добавляет элемент в этот набор битов.

Добавляет все элементы этого набора битов в строковый буфер, используя начальную, конечную и разделительные строки. Записываемый текст начинается со строки 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)

Добавляет все элементы этого итерируемого объекта в строковый буфер. Записываемый текст состоит из строковых представлений (в соответствии с методом 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

Добавляет все элементы этого итерируемого объекта или итератора в строковый билдер с использованием разделителя. Записываемый текст состоит из строковых представлений (с точки зрения метода 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

Агрегирует результаты применения оператора к последующим элементам.

Это более общий вид fold и reduce. Аналогично foldLeft, так как результат не требует быть супертипом типа элемента. Кроме того, он позволяет обрабатывать параллельные коллекции частями, а затем объединять промежуточные результаты.

aggregate разделяет итерируемый объект или итератор на разделы и обрабатывает каждый раздел последовательно, применяя seqop, начиная с z (как в foldLeft). Затем эти промежуточные результаты объединяются с помощью combop (как в fold). Реализация этой операции может работать с произвольным количеством разделов коллекции (даже с 1), поэтому combop может быть вызвана произвольное количество раз (даже 0).

Например, рассмотрим суммирование целочисленных значений списка символов. Начальное значение для суммы равно 0. Во-первых, seqop преобразует каждый входной символ в Int и добавляет его к сумме (раздела). Затем combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

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

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

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

Приводит объект-получатель к типу T0.

Обратите внимание, что успех приведения в рантайме зависит от правил стирания Scala. Поэтому выражение 1.asInstanceOf[String] может выбросить ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] этого не сделает. В последнем примере, поскольку тип аргумента стирается во время компиляции, невозможно проверить, соответствуют ли содержимое списка требуемому типу.

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

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

Создать копию объекта-получателя.

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

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

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

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

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

Компаньон-объект-фабрика, который создаёт экземпляры класса mutable.Set. (или его Iterable суперкласса, где класс mutable.Set не является Seq.)

Функция сравнения, которая упорядочивает ключи.

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

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

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

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

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

Копирует все элементы этого перебираемого объекта или итератора в буфер.

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

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

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

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

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

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

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

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

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

Пустое множество того же типа, что и это множество

Проверяет, является ли аргумент ссылкой на объект-получатель (that) .

Метод eq реализует отношение эквивалентности на непустых экземплярах AnyRef, и обладает тремя дополнительными свойствами:

Он согласован: для любых непустых экземпляров x и y типа AnyRef, несколько вызовов x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого непустого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить согласованность их поведения с равенством ссылок. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и они должны хэшироваться к одному значению (o1.hashCode == o2.hashCode).

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

Примечание: Эта операция содержит неявное приведение: если that является набором, она предположит с неявным приведением, что у него тот же тип элементов, что и у этого набора. Любой последующий ClassCastException обрабатывается как результат false.

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает строку, отформатированную в соответствии с заданной строкой format. Строки формата аналогичны строкам String.format (@см. java.lang.String.format).

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

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

Общий билдер, который строит экземпляры Traversable для произвольных типов элементов.

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

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

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

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

Проверяет, известно ли, что у этой коллекции-обхода конечный размер. Все строгие коллекции известны как имеющие конечный размер. Для нестрогой коллекции, такой как Stream, предикат возвращает true если все элементы были вычислены. Возвращает false если поток ещё не был вычислен до конца. Непустые итераторы обычно возвращают false даже если они были созданы из коллекции с известным конечным размером.

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

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

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

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

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

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

Проверяет, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат теста зависит от семантики стирания типов Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, а выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, из-за стирания аргументов типа во время компиляции, невозможно проверить, содержат ли элементы списка указанный тип.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Эквивалентно !(this eq that).

Общее реализация newBuilder для всех изменяемых множеств в терминах empty. Переопределяет реализацию в collection.SetLike для повышения эффективности.

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

Разбуждает один поток, ожидающий монитора объекта-получателя.

Разбуждает все потоки, ожидающие монитора объекта-получателя.

Количество слов (каждое по 64 бита), составляющих множество.

Возвращает параллельную реализацию этого набора.

Для большинства типов наборов этот метод создаёт новый параллельный набор, копируя все элементы. Для таких наборов метод par занимает линейное время. Изменяемые наборы в этой категории не создают изменяемый параллельный набор с тем же самым базовым набором данных, поэтому изменения в одном наборе не будут отражены в другом.

Некоторые наборы (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельный набор, использующий те же данные. Для этих наборов метод par занимает постоянное или подлинейное время.

Все параллельные наборы возвращают ссылку на самих себя.

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

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

Перемножает элементы этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Удаляет элемент из этого множества.

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

Результат, когда это множество используется как строитель

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

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

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

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

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

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

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

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

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

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

Пример:

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

Версия этой коллекции со всеми операциями, реализованными последовательно (т. е. в однопоточном режиме).

Этот метод возвращает ссылку на эту коллекцию. В параллельных коллекциях он переопределяется для возврата последовательной реализации этой коллекции. В обоих случаях сложность O(1).

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

Указывает, что ожидается, что result этого билдера будет иметь тот же размер, что и заданная коллекция, плюс некоторое значение дельты. Это будет дано только в том случае, если известно, что у коллекции есть метод size с низкой стоимостью. В настоящее время предполагается, что это так, если и только если коллекция имеет тип IndexedSeqLike. Некоторые классы билдеров будут оптимизировать свою структуру на основе этого подсказки. Однако реализации билдера должны корректно работать, даже если подсказка неверна, т. е. добавлено разное количество элементов.

Указывает, что ожидается, что result этого билдера будет иметь тот же размер, что и заданная коллекция, плюс некоторое значение дельты. Эта подсказка будет предоставлена только в том случае, если известно, что у коллекции есть метод size с низкой стоимостью, что определяется вызовом sizeHint.

Некоторые классы билдеров оптимизируют свою структуру на основе подсказки. Тем не менее, реализации билдеров по-прежнему должны работать правильно, даже если подсказка неверна, т. е. добавлено другое количество элементов.

Указывает предполагаемое количество элементов, которые будут добавлены при вызове следующего result. Некоторые классы билдеров оптимизируют свою структуру на основе подсказки. Однако реализации билдеров должны корректно работать, даже если подсказка неверна, т. е. добавлено другое количество элементов.

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

Размер этой коллекции или итератора, если его можно вычислить с низкой стоимостью

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

from <= indexOf(x) < until

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

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

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

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

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

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

Разделяет эту итерируемую коллекцию на две части в заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Определяет префикс представления этого объекта.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Использует содержимое этого набора для создания нового изменяемого буфера.

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

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

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

Возвращает это итерируемое множество как итерируемое множество.

Новый набор не будет создан; ленивые множества останутся ленивыми.

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

Возвращает итератор по элементам в этом итерируемом множестве. Производит тот же результат, что и iterator.

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

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

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

Преобразует этот битсет в карту. Этот метод недоступен, если элементы не являются членами Tuple2, каждый ((T, U)) становится парой ключ-значение в карте. Повторные ключи будут перезаписаны последующими ключами: если это неупорядоченное множество, то какой ключ находится в результирующей карте, не определено.

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

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

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

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

Преобразует это итерируемое множество в поток.

Создает строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе java это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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

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

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

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

Транспонирует этот набор итерируемых наборов в набор наборов.

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

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

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

Создаёт проекцию этого набора с границей снизу.

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

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

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

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

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

Этот метод позволяет добавить или удалить элемент elem из этого набора в зависимости от значения параметра included. Обычно используется следующий синтаксис:

set(elem) = true  // adds element
set(elem) = false // removes element

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

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

Примечание: view(from, to) эквивалентно view.slice(from, to)

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

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

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

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

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

Элементы слова по индексу idx, или 0L, если индекс выходит за пределы набора. Примечание: требует idx >= 0

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

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

Объединяет эту битовую совокупность со своими индексами.

Вычисляет объединение между этой битовой совокупностью и другой битовой совокупностью, выполняя побитовое "или".

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

Примечание: То же самое, что и union.

Обновляет эту битовую совокупность до объединения с другой битовой совокупностью, выполняя побитовое "или".