Класс scala.collection.parallel.immutable.ParRange

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

Эквивалентно 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 immutable parallel range 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 immutable parallel range.

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. В этом случае метод возвращает фабрику, которая каждый раз возвращает тот же комбинатор. Это обычно делается для конкурирующих параллельных коллекций, комбинаторы которых позволяют потокобезопасный доступ.

Фабрика-компаньон, которая создаёт экземпляры класса mutable.ParSeq. (или его Iterable суперкласс, где класс mutable.ParSeq не является Seq.)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности отношение эквивалентности для не-null экземпляров типа AnyRef и обладает тремя дополнительными свойствами:

Он согласован: для любых не-null экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого не-null экземпляра 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)

Преобразует этот неизменяемый параллельный диапазон коллекций 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 может гарантировать, что размер определён и проблема бесконечной итерации не актуальна.

Хеш-коды для 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.

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

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

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

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

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

Обратите внимание, что у этого метода разная сигнатура, чем у методов 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))

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

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

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

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

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

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

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