Трейт scala.collection.parallel.ParMap

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

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

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

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

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

Другой пример — вычисление геометрического среднего арифметического из коллекции значений double (для этого обычно требуются большие значения double).

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

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

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

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

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

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

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

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

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

Проверяет, содержит ли эта карта привязку для ключа.

Копирует элементы этой параллельной карты в массив. Заполняет данный массив 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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

По умолчанию этот метод реализован с использованием защищённого метода splitter.

Собрать все ключи этой карты в итерируемую коллекцию.

Создаёт итератор для всех ключей.

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

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

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

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

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

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

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

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

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

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

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

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

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

Эквивалентно !(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).

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

Определяет префикс представления этого объекта 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))

Возвращает все значения этой карты в итерируемой коллекции.

Создаёт итератор для всех значений в этой карте.

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

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

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

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

Объединяет эту параллельную карту с её индексами.

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