Трейт scala.collection.parallel.mutable.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 возможности сигнализации. Это означает, что разделители могут отправлять и читать seq сигналы.

Применяет функцию 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))

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

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

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

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

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

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