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

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

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

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

Приводит объект-получатель к типу 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).

Метод равенства для ссылочных типов. Реализация по умолчанию делегирует eq.

См. также equals в scala.Any.

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

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

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

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

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

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

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

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

При необходимости повторно использует существующий комбинирователь для повышения производительности. По умолчанию это не делается — подклассы могут переопределять это поведение. Предоставленный комбинирователь 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 это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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

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

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

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

Транспонирует это множество коллекций traversable в множество коллекций.

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

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

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

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

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

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

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

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