Тракт scala.collection.BitSet

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

Пример:

scala> val a = Set(1, 2) ++ Set(2, "a")
a: scala.collection.immutable.Set[Any] = Set(1, 2, a)

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

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

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

Пример:

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

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

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

Пример:

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)

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

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

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

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

Примечание: /: — это альтернативная синтаксическая форма 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 зависит от платформы.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итерирует по начальным сегментам этого итерируемого набора. Первое значение — это сам набор, последнее — пустой набор, промежуточные значения — результаты последовательных применений 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. Переопределено для изменяемых множеств в `mutable.SetLike`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Размер этого набора или итератора, если его можно вычислить недорого

Выбирает интервал элементов. Полученный набор состоит из всех элементов 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)) становится парой ключ-значение в карте. Повторяющиеся ключи перезаписываются более поздними ключами: если это неупорядоченная коллекция, ключ, присутствующий в результирующей карте, не определён.

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

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

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

Преобразует эту итерируемую коллекцию в поток.

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе 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))

Создаёт нестрогую область просмотра среза этого набора данных.

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

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

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

Создаёт нестрогую область просмотра этого набора данных.

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

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

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

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

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

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

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

Сдвоит эту битовую совокупность с её индексами.

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

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

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

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