Класс scala.collection.parallel.immutable.ParHashSet

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

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

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

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

Разность этого множества и другого множества.

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

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

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

Примечание: /: — альтернативная синтаксическая конструкция для 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).

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

Это обобщённая форма fold и reduce. Она имеет аналогичную семантику, но не требует, чтобы результат был супертипом типа элемента. Она перебирает элементы в разных разделах последовательно, используя seqop для обновления результата, а затем применяет combop к результатам из разных разделов. Реализация этой операции может работать с произвольным количеством разделов коллекции, поэтому combop может вызываться произвольное количество раз.

Например, можно обработать некоторые элементы и затем получить Set. В этом случае seqop обработает элемент и добавит его в множество, а combop объединит два множества из разных разделов. Начальное значение z будет пустым множеством.

pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

Ещё один пример — вычисление геометрического среднего из коллекции вещественных чисел (обычно для этого нужны большие вещественные числа).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Метод 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.

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

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

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

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

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

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

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

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

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

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

Например:

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)

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

Обратите внимание, что сигнатура этого метода отличается от сигнатур методов foldLeft и foldRight в трайте Traversable. Результат сворачивания может быть только супертипом параметра типа этой параллельной коллекции T.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт новый итератор разделения для прохода по элементам этой коллекции.

По умолчанию этот метод реализован через защищённый метод splitter.

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

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

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

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

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

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

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

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

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

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

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

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

Равносильно !(this eq that).

Построитель, создающий экземпляры типа Traversable[A]

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

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

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

Возвращает параллельное выполнение этой коллекции.

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

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

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

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

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

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

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

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

Обратите внимание, что у этого метода другой сигнатура, чем у методов reduceLeft и reduceRight трейта Traversable. Результат сведения может быть только супертипом параметра типа этого параллельного набора T.

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

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

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

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

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

Обратите внимание, что у этого метода другой сигнатура, чем у методов reduceLeftOption и reduceRightOption трейта Traversable. Результат сведения может быть только супертипом параметра типа этого параллельного набора T.

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

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

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

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

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

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

Возможная повторная переиспользование существующего объединителя для повышения производительности. По умолчанию не используется - подклассы могут переопределять это поведение. Предоставленный объединитель oldc , который потенциально может быть повторно использован, будет либо некоторым объединителем из предыдущей вычислительной задачи, либо None , если предыдущей фазы не было (в этом случае этот метод должен вернуть newc).

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

Размер этого неизменяемого параллельного набора хешей.

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вот как можно изменить поддержку задач параллельной коллекции:

import scala.collection.parallel._
val pc = mutable.ParArray(1, 2, 3)
pc.tasksupport = new ForkJoinTaskSupport(
  new java.util.concurrent.ForkJoinPool(2))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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