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

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

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

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

Копия параллельного массива с добавленным элементом в начало.

Обратите внимание, что операторы с окончанием «-» являются правоассоциативными (см. пример). Мнемоника для +: по сравнению с :+: двоеточие ставится со стороны коллекции.

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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

Примечание: /: — это альтернативная синтаксическая форма 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

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

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

A copy of this parallel array with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Note: will not terminate for infinite-sized collections.

Example:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Applies a binary operator to all elements of this parallel iterable and a start value, going right to left.

Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

Aggregates the results of applying an operator to subsequent elements.

This is a more general form of fold and reduce. It has similar semantics, but does not require the result to be a supertype of the element type. It traverses the elements in different partitions sequentially, using seqop to update the result, and then applies combop to results from different partitions. The implementation of this operation may operate on an arbitrary number of collection partitions, so combop may be invoked arbitrary number of times.

For example, one might want to process some elements and then produce a Set. In this case, seqop would process an element and append it to the set, while combop would concatenate two sets from different partitions together. The initial value z would be an empty set.

pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

Another example is calculating geometric mean from a collection of doubles (one would typically require big doubles for this).

Selects an element by its index in the parallel array.

Example:

scala> val x = List(1, 2, 3, 4, 5)
x: List[Int] = List(1, 2, 3, 4, 5)

scala> x(3)
res1: Int = 4

Cast the receiver object to be of type T0.

Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт новую параллельную итерируемую последовательность из этой параллельной итерируемой последовательности без дублирования элементов.

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

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

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

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

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

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

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

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

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

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

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

Возвращает представление runtime-класса объекта.

Разбивает этот параллельный итерируемый объект на карту параллельных итерируемых объектов в соответствии с функцией-дискриминатором.

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

Проверяет, известен ли размер этого параллельного итерируемого объекта как конечный. Все строгие коллекции известны как имеющие конечный размер. Для нестрогой коллекции, такой как Stream, предикат возвращает true, если все элементы были вычислены. Он возвращает false, если поток ещё не обработан до конца. Непустые итераторы обычно возвращают false, даже если они были созданы из коллекции с известным конечным размером.

Примечание: многие методы коллекций не будут работать с коллекциями бесконечных размеров. Типичный режим отказа - бесконечный цикл. Эти методы всегда пытаются выполнить обход, не проверяя сначала, что hasDefiniteSize возвращает true. Однако проверка hasDefiniteSize может обеспечить уверенность в том, что размер определён и бесконечная работа не является проблемой.

Хеш-коды для GenSeq производят значение из хеш-кодов всех элементов общей последовательности.

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

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

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

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

Находит индекс первого вхождения некоторого значения в этом параллельном массиве после или на некотором начальном индексе.

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

Находит индекс первого вхождения некоторого значения в этом параллельном массиве.

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

Находит первый элемент, удовлетворяющий некоторому предикату.

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

Флаг индекса изначально устанавливается в максимальное целочисленное значение.

Находит индекс первого элемента, удовлетворяющего некоторому предикату.

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

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

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

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

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

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

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

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

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

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

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

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

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

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

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

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

По умолчанию этот метод реализован через защищённый метод splitter.

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

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

Находит индекс последнего вхождения некоторого значения в этом параллельном массиве до или на заданном индексе конца.

Находит индекс последнего вхождения некоторого значения в этом параллельном массиве.

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

Находит последний элемент, удовлетворяющий некоторому предикату.

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

Флаг индекса изначально устанавливается в минимальное целое значение.

Находит индекс последнего элемента, удовлетворяющего некоторому предикату.

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

Возвращает последний элемент.

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

Длина параллельного массива.

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

Примечание: xs.length и xs.size дают одинаковый результат.

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

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

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

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

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

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

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

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

Эквивалентно !(this eq that).

Построитель, создающий экземпляры типа Traversable[A]

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

Разбуживает единственную нить, ожидающую монитора объекта-получателя.

Разбуживает все нити, ожидающие монитора объекта-получателя.

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

Возвращает параллельную реализацию этой коллекции.

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

Конкретные коллекции (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая использует ту же базу данных. Для этих коллекций par занимает постоянное или сублинейное время.

Все параллельные коллекции возвращают ссылку на себя.

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

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

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

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

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

Перемножает элементы этой коллекции.

Сводит элементы этой последовательности с помощью указанного ассоциативного бинарного оператора.

Порядок выполнения операций над элементами не определён и может быть недетерминированным.

Обратите внимание, что этот метод имеет другую сигнатуру, чем методы reduceLeft и reduceRight трейта Traversable. Результат сокращения может быть только надтипом параметра типа этой параллельной коллекции T.

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

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

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

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

Порядок выполнения операций над элементами не определен и может быть недетерминированным.

Обратите внимание, что этот метод имеет разный синтаксис, чем методы reduceLeftOption и reduceRightOption в трайте Traversable. Результат сокращения может быть только надтипом параметра типа этой параллельной коллекции T.

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

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

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

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

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

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

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

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

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

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

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

Примечание: xs.reverseMap(f) эквивалентно xs.reverse.map(f), но может быть более эффективным.

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

Флаг индекса первоначально устанавливается в максимальное целочисленное значение.

Размер этого параллельного итерируемого объекта.

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

Размер этого набора или итератора, если он может быть вычислен дёшево

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

from <= indexOf(x) < until

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

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

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

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

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

Более усовершенствованная версия итератора, найденного в трайте ParallelIterable, этот итератор может быть разделен на произвольные подмножества итераторов.

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

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

Проверяет, начинается ли эта общая последовательность с заданной последовательности.

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

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

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

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

Транспонирует этот коллекцию итерируемых коллекций в коллекцию коллекций.

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

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

Создаёт новую последовательность, которая содержит все элементы этого параллельного массива, а также все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это — xs union ys вычисляет сохраняющую порядок много-множественную сумму xs и ys. union, следовательно, является аналогом diff и intersect, которые также работают с много-множествами.

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

Преобразует этот коллекцию пар в две коллекции первой и второй половины каждой пары.

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

Копия этого параллельного массива с заменой одного элемента.

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

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

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

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

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

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