Трейт scala.collection.parallel.immutable.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)

Преобразует эту параллельную итерируемую коллекцию из коллекций Traversable в параллельную итерируемую коллекцию, образованную элементами этих коллекций Traversable.

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

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

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

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

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

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

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

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

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

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

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

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

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

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