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

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

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

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

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

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

Мнемоника для +: против :+ такова: двоеточие ставится к коллекции.

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

Пример:

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)

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

Примечание: :\ — это альтернативная синтаксическая форма 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 значениями этого параллельного итерируемого объекта. Копирование остановится, как только будет достигнут конец текущего параллельного итерируемого объекта или конец целевого массива.

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

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

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

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

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

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

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

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

Хешкоды для GenSeq генерируют значение из хешкодов всех элементов последовательности.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Находит первый элемент, который даёт наибольшее значение, измеренное функцией 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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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