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

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

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

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

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

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

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

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

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

добавляет один элемент в это параллельное множество хешей.

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

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

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

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

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

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

Добавить elem, если его ещё нет в таблице.

Добавить запись (elem, преобразованную в запись с помощью elemToEntry), если её ещё нет в таблице.

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

Это более общий вид 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]] этого не сделает. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, содержатся ли элементы списка в требуемом типе.

Очищает содержимое параллельного набора 's. После этой операции параллельный набор пуст.

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

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

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

на котором функция определена.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Элементы имеют тип A, но мы храним AnyRef в таблице. Кроме того, нам нужно справиться с нулевыми элементами, которые должны храниться как NullSentinel

Выполняет обратное преобразование elemToEntry

Проверяет, является ли аргумент (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.

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

Этот метод будет использовать возможности сигнализации 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 (@см. 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.

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

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

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

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

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

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

Удаляет элемент из хеш-таблицы, возвращая true, если элемент был найден (и, следовательно, удален), или false, если его не существовало.

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

Размер этого параллельного множества.

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

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

Массив, отслеживающий количество элементов в блоках по 32 элемента.

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

Фактическая хеш-таблица.

Количество сопоставлений, содержащихся в этой хеш-таблице.

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

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

Выбирает первые 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.