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

Компаньон объект ParSeq

трейт ParSeq[+T] extends GenSeq[T] with parallel.ParSeq[T] with ParIterable[T] with GenericParTemplate[T, ParSeq] with ParSeqLike[T, ParSeq[T], immutable.Seq[T]]

Неизменяемый вариант ParSeq.

Источник: ParSeq.scala

Линейные супертипы

Известные подклассы

Члены типов

класс Aggregate[S] extends Accessor[S, Aggregate[S]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

тракт BuilderOps[Elem, To] extends AnyRef

Определяющие классы: ParIterableLike

класс Collect[S, That] extends Transformer[Combiner[S, That], Collect[S, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

абстрактный класс Composite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Copy[U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]

Атрибуты: protected
Определяющие классы: ParIterableLike

класс CopyToArray[U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Count extends Accessor[Int, Count]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс CreateScanTree[U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Drop[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Exists extends Accessor[Boolean, Exists]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Filter[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс FilterNot[U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Find[U >: T] extends Accessor[Option[U], Find[U]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс FlatMap[S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Fold[U >: T] extends Accessor[U, Fold[U]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Forall extends Accessor[Boolean, Forall]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Foreach[S] extends Accessor[Единица, Foreach[S]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс FromScanTree[U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс GroupBy[K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Map[S, That] extends Transformer[Combiner[S, That], Map[S, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Max[U >: T] extends Accessor[Option[U], Max[U]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Min[U >: T] extends Accessor[Option[U], Min[U]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

тракт NonDivisible[R] extends NonDivisibleTask[R, NonDivisible[R]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

тракт NonDivisibleTask[R, Tp] extends StrictSplitterCheckTask[R, Tp]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

абстрактный класс ParComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

Выполняет две задачи параллельно и ждет завершения обеих.

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Partition[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс Product[U >: T] extends Accessor[U, Product[U]]

Атрибуты: protected[this]
Классы определений: ParIterableLike

класс Reduce[U >: T] extends Accessor[Option[U], Reduce[U]]

Атрибуты: protected[this]
Классы определений: ParIterableLike

абстрактный класс ResultMapping[R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]

Атрибуты: protected[this]
Классы определений: ParIterableLike

случайный класс ScanLeaf[U >: T](pit: IterableSplitter[U], op: (U, U) ⇒ U, from: Int, len: Int, prev: Option[ScanLeaf[U]], acc: U) extends ScanTree[U] with scala.Product with Serializable

Атрибуты: protected[this]
Классы определений: ParIterableLike

случайный класс ScanNode[U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable

Атрибуты: protected[this]
Классы определений: ParIterableLike

тракт ScanTree[U >: T] extends AnyRef

Атрибуты: protected[this]
Классы определений: ParIterableLike

абстрактный класс SeqComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

Последовательно выполняет одну задачу за другой.

Атрибуты: protected[this]
Классы определений: ParIterableLike

тракт SignallingOps[PI <: DelegatedSignalling] extends AnyRef

Классы определений: ParIterableLike

класс Slice[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]

Атрибуты: protected[this]
Классы-определения: ParIterableLike

класс Span[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]

Атрибуты: protected[this]
Классы-определения: ParIterableLike

класс SplitAt[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]

Атрибуты: protected[this]
Классы-определения: ParIterableLike

трайт StrictSplitterCheckTask[R, Tp] extends Task[R, Tp]

Атрибуты: protected
Классы-определения: ParIterableLike

класс Sum[U >: T] extends Accessor[U, Sum[U]]

Атрибуты: protected[this]
Классы-определения: ParIterableLike

класс Take[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]

Атрибуты: protected[this]
Классы-определения: ParIterableLike

класс TakeWhile[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]

Атрибуты: protected[this]
Классы-определения: ParIterableLike

трайт TaskOps[R, Tp] extends AnyRef

Классы-определения: ParIterableLike

класс ToParCollection[U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс ToParMap[K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

класс ZipAll[U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

тракт Accessor[R, Tp] extends ParSeqLike.Accessor[R, Tp]

Атрибуты: protected
Определяющие классы: ParSeqLike

класс Corresponds[S] extends Accessor[Boolean, Corresponds[S]]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

абстрактный класс Elements extends SeqSplitter[T] with scala.BufferedIterator[T]

Используется для итерации элементов с помощью индексов

Атрибуты: protected
Определяющие классы: ParSeqLike

класс IndexWhere extends Accessor[Int, IndexWhere]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

класс LastIndexWhere extends Accessor[Int, LastIndexWhere]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

класс Reverse[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Reverse[U, This]]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

класс ReverseMap[S, That] extends Transformer[Combiner[S, That], ReverseMap[S, That]]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

класс SameElements[U >: T] extends Accessor[Boolean, SameElements[U]]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

класс SegmentLength extends Accessor[(Int, Boolean), SegmentLength]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

тракт Transformer[R, Tp] extends Accessor[R, Tp] with ParSeqLike.Transformer[R, Tp]

Атрибуты: protected
Определяющие классы: ParSeqLike

класс Updated[U >: T, That] extends Transformer[Combiner[U, That], Updated[U, That]]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

класс Zip[U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

тип SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]

Определяющие классы: ParIterableLike

тип SuperParIterator = IterableSplitter[T]

Атрибуты: protected[this]
Определяющие классы: ParSeqLike

Члены-значения абстрактного типа

abstract def apply(i: Int): T

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

Пример:

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

scala> x(3)
res1: Int = 4

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

Определяющие классы: ParSeq → GenSeqLike
Исключения: IndexOutOfBoundsException, если idx не удовлетворяет 0 <= idx < length.

abstract def length: Int

Длина общей последовательности.

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

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

возвращает: количество элементов в этой общей последовательности.

Определяющие классы: GenSeqLike
Исключения: IllegalArgumentException, если длина последовательности не может быть представлена в Int, например, (-1 to Int.MaxValue).length.

abstract def seq: immutable.Seq[T]

Определяющие классы: ParIterableLike → Parallelizable → GenTraversableOnce

abstract def splitter: SeqSplitter[T]

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

возвращает: итератор, который можно разделить на подмножества точного размера

Атрибуты: protected[parallel]
Определяющие классы: ParSeqLike → ParIterableLike

Члены-значения конкретного типа

final def !=(arg0: Any): Boolean

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

returns: true если !(this == that), в противном случае false.

Definition Classes: AnyRef → Any

final def ##(): Int

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

returns: хеш-значение, согласованное с ==

Definition Classes: AnyRef → Any

def +(other: String): String

Неявный: Этот член добавлен благодаря неявной конверсии из ParSeq[T] в any2stringadd[ParSeq[T]], выполненной методом any2stringadd в scala.Predef.
Definition Classes: any2stringadd

def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParSeq[T], U, That]): That

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

That: класс возвращаемого набора. Где возможно, That — это тот же класс, что и текущий класс коллекции Repr, но это зависит от типа элемента B , который должен быть допустимым для этого класса, что означает, что найден неявный экземпляр типа CanBuildFrom[Repr, B, That].
that: итерируемое множество для добавления.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That по текущему типу представления Repr и новому типу элемента B.
returns: новый набор типа That, который содержит все элементы этого параллельного итерируемого множества, за которыми следуют все элементы that.

Definition Classes: ParIterableLike → GenTraversableLike

def +:(elem: A): mutable.ParSeq[A]

[use case]

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

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

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

Пример:

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)

elem: элемент, добавляемый в начало
returns: новая изменяемая параллельная последовательность, состоящая из elem и всех элементов этой изменяемой параллельной последовательности.

Definition Classes: ParSeqLike → GenSeqLike

def ->[B](y: B): (ParSeq[T], B)

Неявный: Этот член добавлен благодаря неявной конверсии из ParSeq[T] в ArrowAssoc[ParSeq[T]], выполненной методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @inline()

def /:[S](z: S)(op: (S, T) ⇒ S): S

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

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

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

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

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого параллельного итерируемого множества слева направо с начальным значением z слева:

op(...op(op(z, x_1), x_2), ..., x_n)

где x₁, ..., x_n — это элементы этого параллельного итерируемого множества.

Definition Classes: ParIterableLike → GenTraversableOnce

def :+(elem: A): mutable.ParSeq[A]

[use case]

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

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

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

Пример:

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)

elem: добавляемый элемент
returns: новая изменяемая параллельная последовательность, состоящая из всех элементов этой изменяемой параллельной последовательности, за которыми следует elem.

Definition Classes: ParSeqLike → GenSeqLike

def :\[S](z: S)(op: (T, S) ⇒ S): S

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

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

z

начальное значение

op

бинарный оператор

returns

результат вставки op между последовательными элементами этого параллельного итерируемого объекта, слева направо, с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — элементы этого параллельного итерируемого объекта.

Definition Classes: ParIterableLike → GenTraversableOnce

final def ==(arg0: Any): Boolean

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

returns: true если объект получателя эквивалентен аргументу; false в противном случае.

Definition Classes: AnyRef → Any

def aggregate[S](z: ⇒ S)(seqop: (S, T) ⇒ S, combop: (S, S) ⇒ S): S

Агрегирует результаты применения оператора к последующим элементам.

Это более общий случай fold и reduce. Он имеет схожую семантику, но не требует, чтобы результат был супертипом типа элемента. Он последовательно обходит элементы в разных разделах, используя seqop для обновления результата, а затем применяет combop к результатам из разных разделов. Реализация этой операции может работать с произвольным количеством разделов коллекции, поэтому combop может быть вызвана произвольное количество раз.

Например, можно обработать некоторые элементы и затем произвести Set. В этом случае seqop будет обрабатывать элемент и добавлять его в множество, в то время как combop будет конкатенировать два множества из разных разделов вместе. Начальное значение z будет пустым множеством.

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

Другой пример — вычисление геометрической средней арифметической последовательности чисел с плавающей точкой (обычно для этого потребуются большие числа с плавающей точкой).

final def asInstanceOf[T0]: T0

Преобразует объект получателя к типу T0.

Обратите внимание, что успех приведения типов во время выполнения обусловлен семантикой стирания Scala. Поэтому выражение 1.asInstanceOf[String] выбросит исключение ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] — нет. В последнем примере, поскольку аргумент типа стирается на этапе компиляции, невозможно проверить, соответствуют ли содержимое списка запрошенному типу.

def bf2seq[S, That](bf: CanBuildFrom[ParSeq[T], S, That]): CanBuildFrom[immutable.Seq[T], S, That]

Attributes: protected[this]
Definition Classes: ParIterableLike

неявный def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]

Атрибуты: protected
Определяющие классы: ParIterableLike

def canEqual(other: Any): Boolean

Определяющие классы: ParIterableLike

def clone(): AnyRef

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

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

возвращает: копию объекта-получателя.

Атрибуты: protected[lang]
Определяющие классы: AnyRef
Аннотации: @throws( ... ) @native()
Примечание: не определён в SLS как член AnyRef

def collect[B](pf: PartialFunction[A, B]): mutable.ParSeq[B]

[случаи использования]

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

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

Определяющие классы: ParIterableLike → GenTraversableLike

def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

def combinerFactory: CombinerFactory[T, ParSeq[T]]

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

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

Атрибуты: protected[this]
Определяющие классы: ParIterableLike

def companion: GenericCompanion[ParSeq] with GenericParCompanion[ParSeq]

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

Определяющие классы: ParSeq → ParIterable → ParSeq → ParIterable → GenericParTemplate → GenSeq → GenIterable → GenTraversable → GenericTraversableTemplate

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

[случаи использования]

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

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

xs: массив для заполнения.
start: начальный индекс.
len: максимальное количество копируемых элементов.

Определяющие классы: ParIterableLike → GenTraversableOnce

def copyToArray(xs: Array[A], start: Int): Unit

[use case]

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

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

xs: массив для заполнения.
start: начальный индекс.

Definition Classes: ParIterableLike → GenTraversableOnce

def copyToArray(xs: Array[A]): Unit

[use case]

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

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

xs: массив для заполнения.

Definition Classes: ParIterableLike → GenTraversableOnce

def corresponds[S](that: GenSeq[S])(p: (T, S) ⇒ Boolean): Boolean

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

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

S: тип элементов that
that: другая параллельная последовательность
p: условие предиката, которое связывает элементы из обеих последовательностей
возвращает: true, если обе параллельные последовательности имеют одинаковую длину, и p(x, y) является true для всех соответствующих элементов x этой параллельной итерируемой последовательности и y that, в противном случае false

Definition Classes: ParSeqLike → GenSeqLike

def count(p: (T) ⇒ Boolean): Int

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def debugBuffer: ArrayBuffer[String]

Definition Classes: ParIterableLike

implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]

Attributes: protected
Definition Classes: ParIterableLike

def diff(that: GenSeq[A]): mutable.ParSeq[A]

[use case]

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

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

that: последовательность элементов для удаления
возвращает: новую изменяемую параллельную последовательность, которая содержит все элементы этой изменяемой параллельной последовательности, за исключением некоторых вхождений элементов, которые также присутствуют в that. Если значение элемента x появляется n раз в that, то первые n вхождений x не будут частью результата, но все последующие вхождения будут.

Definition Classes: ParSeqLike → GenSeqLike

def distinct: ParSeq[T]

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

def down(p: IterableSplitter[_]): SeqSplitter[T]

Attributes: protected[this]
Definition Classes: ParSeqLike

def drop(n: Int): ParSeq[T]

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def dropWhile(pred: (T) ⇒ Boolean): ParSeq[T]

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

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

pred: предикат, используемый для проверки элементов
returns: коллекция, составленная из всех элементов после самого длинного префикса элементов в этом параллельном итерируемом объекте, которые удовлетворяют предикату pred

Definition Classes: ParIterableLike → GenTraversableLike

def endsWith[S](that: GenSeq[S]): Boolean

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

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

S: тип элементов последовательности that
that: последовательность для проверки
returns: true если этот параллельный итерируемый объект имеет that в качестве суффикса, false в противном случае

Definition Classes: ParSeqLike → GenSeqLike

def ensuring(cond: (ParSeq[T]) ⇒ Boolean, msg: ⇒ Any): ParSeq[T]

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в Ensuring[ParSeq[T]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (ParSeq[T]) ⇒ Boolean): ParSeq[T]

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в Ensuring[ParSeq[T]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): ParSeq[T]

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в Ensuring[ParSeq[T]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean): ParSeq[T]

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в Ensuring[ParSeq[T]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

final def eq(arg0: AnyRef): Boolean

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

Метод eq реализует отношение эквивалентности на не-null экземплярах 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).

returns: true если аргумент является ссылкой на объект-получатель; false в противном случае.

Definition Classes: AnyRef

def equals(that: Any): Boolean

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

that: Объект для сравнения с последовательностью
returns: true если that является последовательностью, имеющей те же элементы, что и эта последовательность в том же порядке, false в противном случае

Definition Classes: GenSeqLike → Equals → Any

def exists(p: (T) ⇒ Boolean): Boolean

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

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

p: предикат, используемый для проверки элементов
returns: true, если p выполняется для некоторого элемента, false в противном случае

Definition Classes: ParIterableLike → GenTraversableOnce

def filter(pred: (T) ⇒ Boolean): ParSeq[T]

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

pred: предикат, используемый для проверки элементов.
returns: новый параллельный итерируемый объект, состоящий из всех элементов этого параллельного итерируемого объекта, удовлетворяющих заданному предикату p. Их порядок может быть не сохранён.

Definition Classes: ParIterableLike → GenTraversableLike

def filterNot(pred: (T) ⇒ Boolean): ParSeq[T]

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

pred: предикат, используемый для проверки элементов.
returns: новый параллельный итерируемый объект, состоящий из всех элементов этого параллельного итерируемого объекта, которые не удовлетворяют заданному предикату p. Их порядок может быть не сохранён.

Definition Classes: ParIterableLike → GenTraversableLike

def finalize(): Unit

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

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

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )
Note: не специфицировано SLS как член AnyRef

def find(p: (T) ⇒ Boolean): Option[T]

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

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

p: предикат, используемый для проверки элементов
returns: значение Option с элементом, если такой элемент существует, или None в противном случае

Definition Classes: ParIterableLike → GenTraversableOnce

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): mutable.ParSeq[B]

[use case]

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

Например:

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)

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новая изменяемая параллельная последовательность, полученная путём применения заданной функции-коллекции f к каждому элементу этой изменяемой параллельной последовательности и конкатенации результатов.

Definition Classes: ParIterableLike → GenTraversableLike

def flatten[B]: mutable.ParSeq[B]

[use case]

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

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

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)

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

Definition Classes: GenericTraversableTemplate

def fold[U >: T](z: U)(op: (U, U) ⇒ U): U

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

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

U: параметр типа для бинарного оператора, являющийся супертипом T.
z: нейтральный элемент для операции сворачивания. Он может быть добавлен к результату произвольное количество раз, не изменяя результат (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения)
op: бинарный оператор, который должен быть ассоциативным
returns: результат применения оператора сворачивания op между всеми элементами и z

Definition Classes: ParIterableLike → GenTraversableOnce

def foldLeft[S](z: S)(op: (S, T) ⇒ S): S

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

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

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

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого параллельного итератора слева направо с начальным значением z слева:

op(...op(z, x_1), x_2, ..., x_n)

где x₁, ..., x_n — элементы этого параллельного итератора. Возвращает z если этот параллельный итератор пуст.

Definition Classes: ParIterableLike → GenTraversableOnce

def foldRight[S](z: S)(op: (T, S) ⇒ S): S

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

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

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого параллельного итератора справа налево с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — элементы этого параллельного итератора. Возвращает z если этот параллельный итератор пуст.

Definition Classes: ParIterableLike → GenTraversableOnce

def forall(p: (T) ⇒ Boolean): Boolean

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

p: предикат, используемый для проверки элементов
returns: true, если p выполняется для всех элементов, иначе false

Definition Classes: ParIterableLike → GenTraversableOnce

def foreach[U](f: (T) ⇒ U): Unit

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

U: тип результата функции, применяемой к каждому элементу, который всегда отбрасывается
f: функция, применяемая к каждому элементу

Definition Classes: ParIterableLike → GenTraversableLike → GenTraversableOnce

def formatted(fmtstr: String): String

Возвращает строку, отформатированную в соответствии с заданной строкой format. Формат строк аналогичен String.format (@см. java.lang.String.format).

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в StringFormat[ParSeq[T]] с помощью метода StringFormat в scala.Predef.
Определяющие классы: StringFormat
Аннотации: @inline()

def genericBuilder[B]: Combiner[B, ParSeq[B]]

Общий билдер, создающий экземпляры Traversable с произвольными типами элементов.

Определяющие классы: GenericParTemplate → GenericTraversableTemplate

def genericCombiner[B]: Combiner[B, ParSeq[B]]

Определяющие классы: GenericParTemplate

final def getClass(): Class[_]

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

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

Определяющие классы: AnyRef → Any
Аннотации: @native()

def groupBy[K](f: (T) ⇒ K): ParMap[K, ParSeq[T]]

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

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

K

тип ключей, возвращаемых функцией-дискриминатором.

f

функция-дискриминатор.

возвращает

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

(xs groupBy f)(k) = xs filter (x => f(x) == k)

То есть каждый ключ k связан с параллельным множеством тех элементов x, для которых f(x) равно k.

Определяющие классы: ParIterableLike → GenTraversableLike

def hasDefiniteSize: Boolean

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

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

возвращает: true если эта коллекция, как известно, имеет конечный размер, false в противном случае.

Определяющие классы: ParIterableLike → GenTraversableOnce

def hashCode(): Int

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

возвращает: значение хеш-кода для этого объекта.

Определяющие классы: GenSeqLike → Any

def head: T

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

возвращает: первый элемент этого параллельного множества.

Определяющие классы: ParIterableLike → GenTraversableLike
Исключения: NoSuchElementException если параллельное множество пусто.

def headOption: Option[T]

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

возвращает: первый элемент этого параллельного множества, если оно не пусто, None если оно пусто.

Определяющие классы: ParIterableLike → GenTraversableLike

def indexOf(elem: T, from: Int): Int

[use case]

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

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

elem: значение элемента, для которого нужно выполнить поиск.
from: начальный индекс
returns: индекс >= from первого элемента этой изменяемой параллельной последовательности, который равен (как определяется ==) elem, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def indexOf(elem: T): Int

[use case]

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

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

elem: значение элемента, для которого нужно выполнить поиск.
returns: индекс первого элемента этой изменяемой параллельной последовательности, который равен (как определяется ==) elem, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def indexWhere(p: (T) ⇒ Boolean, from: Int): Int

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

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

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

p: предикат, используемый для проверки элементов
from: смещение начала поиска
returns: индекс >= from первого элемента этой параллельной итерируемой последовательности, удовлетворяющего предикату p, или -1, если такого элемента нет.

Definition Classes: ParSeqLike → GenSeqLike

def indexWhere(p: (T) ⇒ Boolean): Int

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

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

p: предикат, используемый для проверки элементов.
returns: индекс первого элемента этой общей последовательности, удовлетворяющего предикату p, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def init: ParSeq[T]

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

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

returns: параллельная итерируемая последовательность, состоящая из всех элементов этой параллельной итерируемой последовательности, кроме последнего.

Definition Classes: ParIterableLike → GenTraversableLike
Exceptions thrown: UnsupportedOperationException, если параллельная итерируемая последовательность пуста.

def initTaskSupport(): Unit

Attributes: protected
Definition Classes: ParIterableLike

def intersect(that: scala.Seq[T]): mutable.ParSeq[T]

[use case]

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

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

that: последовательность элементов для пересечения.
returns: новая изменяемая параллельная последовательность, которая содержит все элементы этой изменяемой параллельной последовательности, которые также появляются в that. Если значение элемента x встречается n раз в that, то первые n вхождений x будут сохранены в результате, но любые последующие вхождения будут пропущены.

Definition Classes: ParSeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

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

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

idx: индекс для проверки
returns: true , если в этой общей последовательности есть элемент в позиции idx, false в противном случае.

Definition Classes: GenSeqLike

def isEmpty: Boolean

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

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

returns: true , если параллельная итерируемая последовательность не содержит элементов, false в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

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

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

returns: true, если объект-приёмник является экземпляром стирания типа T0; false в противном случае.

Definition Classes: Any

def isStrictSplitterCollection: Boolean

Указывает, имеет ли это параллельное множество жёсткие разделители.

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

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

Definition Classes: ParIterableLike

final def isTraversableAgain: Boolean

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

returns: true

Definition Classes: ParIterableLike → GenTraversableLike → GenTraversableOnce

def iterator: PreciseSplitter[T]

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

По умолчанию этот метод реализован с помощью защищённого метода splitter.

returns: итератор разделения

Definition Classes: ParSeqLike → ParIterableLike → GenIterableLike

def last: T

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

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

returns: Последний элемент этого параллельного итерируемого объекта.

Definition Classes: ParIterableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException Если параллельное множество пусто.

def lastIndexOf(elem: T, end: Int): Int

[use case]

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

elem: значение искомого элемента.
end: конечный индекс.
returns: индекс <= end последнего элемента этой изменяемой параллельной последовательности, который равен (как определено ==) elem, или -1, если такой элемент не существует.

Definition Classes: GenSeqLike

def lastIndexOf(elem: T): Int

[use case]

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

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

elem: значение искомого элемента.
returns: индекс последнего элемента этой изменяемой параллельной последовательности, который равен (как определено ==) elem, или -1, если такой элемент не существует.

Definition Classes: GenSeqLike

def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int

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

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

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

p: предикат для проверки элементов
end: максимальный смещение для поиска
returns: индекс <= end первого элемента этой параллельной итерируемой последовательности, удовлетворяющего предикату p, или -1, если такой элемент не существует.

Definition Classes: ParSeqLike → GenSeqLike

def lastIndexWhere(p: (T) ⇒ Boolean): Int

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

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

p: предикат для проверки элементов.
returns: индекс последнего элемента этой общей последовательности, удовлетворяющего предикату p, или -1, если такой элемент не существует.

Definition Classes: GenSeqLike

def lastOption: Option[T]

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

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

returns: последний элемент этого параллельного итерируемого объекта, если он не пуст, None если он пуст.

Definition Classes: ParIterableLike → GenTraversableLike

def map[B](f: (A) ⇒ B): mutable.ParSeq[B]

[use case]

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

B: тип элементов возвращаемой коллекции.
f: функция, которая применяется к каждому элементу.
returns: новая изменяемая параллельная последовательность, полученная путём применения заданной функции f к каждому элементу этой изменяемой параллельной последовательности и сбора результатов.

Definition Classes: ParIterableLike → GenTraversableLike

def max: A

[use case]

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

returns: наибольший элемент этой изменяемой параллельной последовательности.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая параллельная последовательность пуста.

def maxBy[B](f: (A) ⇒ B): A

[use case]

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

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой изменяемой параллельной последовательности с наибольшим значением, измеренным функцией f.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая параллельная последовательность пуста.

def min: A

[use case]

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

returns: наименьший элемент этой изменяемой параллельной последовательности

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая параллельная последовательность пуста.

def minBy[B](f: (A) ⇒ B): A

[use case]

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

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой изменяемой параллельной последовательности с наименьшим значением, измеренным функцией f.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая параллельная последовательность пуста.

def mkString: String

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

returns: строковое представление этого параллельного итерируемого объекта. В результирующей строке строковые представления (с учётом метода toString) всех элементов этого параллельного итерируемого объекта следуют друг за другом без разделителя.

Definition Classes: ParIterableLike → GenTraversableOnce

def mkString(sep: String): String

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

sep: строка-разделитель.
returns: строковое представление этого параллельного итерируемого объекта. В результирующей строке строковые представления (с учётом метода toString) всех элементов этого параллельного итерируемого объекта разделяются строкой sep.

Definition Classes: ParIterableLike → GenTraversableOnce

def mkString(start: String, sep: String, end: String): String

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

start: начальная строка.
sep: строка-разделитель.
end: конечная строка.
returns: строковое представление этого параллельного итерируемого объекта. Результирующая строка начинается со строки start и заканчивается строкой end. Внутри строковые представления (с учётом метода toString) всех элементов этого параллельного итерируемого объекта разделяются строкой sep.

Definition Classes: ParIterableLike → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

Равносильно !(this eq that).

returns: true если аргумент не является ссылкой на объект-получатель; false в противном случае.

Definition Classes: AnyRef

def newBuilder: Builder[T, ParSeq[T]]

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

Attributes: protected[this]
Definition Classes: GenericParTemplate → GenericTraversableTemplate → HasNewBuilder

def newCombiner: Combiner[T, ParSeq[T]]

Attributes: protected[this]
Definition Classes: GenericParTemplate → HasNewCombiner

def nonEmpty: Boolean

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

returns: true если параллельное итерируемое содержит по крайней мере один элемент, false в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

final def notify(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Note: не указано SLS как член AnyRef

final def notifyAll(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Note: не указано SLS как член AnyRef

def padTo(len: Int, elem: A): mutable.ParSeq[A]

[use case]

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

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

Definition Classes: ParSeqLike → GenSeqLike

def par: ParSeq[T]

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

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

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

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

returns: параллельная реализация этого набора

Definition Classes: ParIterableLike → CustomParallelizable → Parallelizable

def parCombiner: Combiner[T, ParSeq[T]]

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

returns: комбинировщик для параллельного набора типа ParRepr

Attributes: protected[this]
Definition Classes: CustomParallelizable → Parallelizable

def partition(pred: (T) ⇒ Boolean): (ParSeq[T], ParSeq[T])

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

pred: предикат для разбиения.
returns: пара параллельных итерируемых: первое параллельное итерируемое состоит из всех элементов, которые удовлетворяют предикату p, а второе параллельное итерируемое состоит из всех элементов, которые не удовлетворяют. Относительный порядок элементов в результирующих параллельных итерируемых может быть не сохранен.

Definition Classes: ParIterableLike → GenTraversableLike

def patch(from: Int, that: GenSeq[A], replaced: Int): mutable.ParSeq[A]

[use case]

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

from: индекс первого заменяемого элемента
replaced: количество элементов для удаления в исходной мутабельной параллельной последовательности
returns: новая мутабельная параллельная последовательность, содержащая все элементы этой мутабельной параллельной последовательности, за исключением того, что replaced элементов, начиная с from, заменены на patch.

Definition Classes: ParSeqLike → GenSeqLike

def prefixLength(p: (T) ⇒ Boolean): Int

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

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

p: предикат, используемый для проверки элементов.
returns: длина самого длинного префикса этой общей последовательности, такой что каждый элемент сегмента удовлетворяет предикату p.

Definition Classes: GenSeqLike

def product: A

[use case]

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

returns: произведение всех элементов в этой мутабельной параллельной последовательности чисел типа Int. Вместо Int, может быть использован любой другой тип T с неявной реализацией Numeric[T] в качестве типа элемента мутабельной параллельной последовательности и типа возвращаемого значения product. Примерами таких типов являются: Long, Float, Double, BigInt.

Definition Classes: ParIterableLike → GenTraversableOnce

def reduce[U >: T](op: (U, U) ⇒ U): U

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

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

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

U: Параметр типа для бинарного оператора, надтип T.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Результат применения оператора reduce op между всеми элементами, если коллекция не пустая.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта параллельная итерируемая коллекция пуста.

def reduceLeft[U >: T](op: (U, T) ⇒ U): U

Definition Classes: ParIterableLike

def reduceLeftOption[U >: T](op: (U, T) ⇒ U): Option[U]

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

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

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

op: бинарный оператор.
returns: значение типа Option, содержащее результат reduceLeft(op) , если эта параллельная итерируемая коллекция не пуста, None в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def reduceOption[U >: T](op: (U, U) ⇒ U): Option[U]

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

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

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

U: Параметр типа для бинарного оператора, надтип T.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Значение типа Option, содержащее результат применения оператора reduce op между всеми элементами, если коллекция не пустая, и None в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def reduceRight[U >: T](op: (T, U) ⇒ U): U

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

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

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

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого параллельного итерируемого объекта, справа налево:

op(x_1, op(x_2, ..., op(x_{n-1}, x_n)...))

где x₁, ..., x_n — элементы этого параллельного итерируемого объекта.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если этот параллельный итерируемый объект пуст.

def reduceRightOption[U >: T](op: (T, U) ⇒ U): Option[U]

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

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

op: бинарный оператор.
returns: значение типа Option, содержащее результат reduceRight(op) если этот параллельный итерируемый объект не пуст, None в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def repr: ParSeq[T]

Definition Classes: ParIterableLike → GenTraversableLike

def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]

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

oldc: Комбинатор, который является результатом предыдущей задачи, или None, если не было предыдущей задачи.
newc: Новый пустой комбинатор, который можно использовать.
returns: Либо newc, либо oldc.

Attributes: protected
Definition Classes: ParIterableLike

def reverse: ParSeq[T]

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

def reverseMap[B](f: (A) ⇒ B): mutable.ParSeq[B]

[use case]

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

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

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

B: тип элементов возвращаемой коллекции.
f: функция для применения к каждому элементу.
returns: новая изменяемая параллельная последовательность, полученная путем применения заданной функции f к каждому элементу этой изменяемой параллельной последовательности и сбора результатов в обратном порядке.

Definition Classes: ParSeqLike → GenSeqLike

def sameElements(that: GenIterable[A]): Boolean

[use case]

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

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

that: коллекция для сравнения.
returns: true, если обе коллекции содержат те же элементы в том же порядке, false в противном случае.

Definition Classes: ParSeqLike → ParIterableLike → GenIterableLike

def scan(z: T)(op: (T, T) ⇒ T): mutable.ParSeq[T]

[use case]

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

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

z: нейтральный элемент для оператора op
op: ассоциативный оператор для сканирования
returns: новая изменяемая параллельная последовательность, содержащая префиксное сканирование элементов в этой изменяемой параллельной последовательности

Definition Classes: ParIterableLike → GenTraversableLike

def scanBlockSize: Int

Attributes: protected[this]
Definition Classes: ParIterableLike

def scanLeft[S, That](z: S)(op: (S, T) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[T], S, That]): That

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

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

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

That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: неявное значение класса CanBuildFrom, определяющее класс результата That из текущего типа представления Repr и нового типа элемента B.
returns: коллекция с промежуточными результатами

Definition Classes: ParIterableLike → GenTraversableLike

def scanRight[S, That](z: S)(op: (T, S) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[T], S, That]): That

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

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

Пример:

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

That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: неявное значение класса CanBuildFrom, определяющее класс результата That из текущего типа представления Repr и нового типа элемента B.
returns: коллекция с промежуточными результатами

Definition Classes: ParIterableLike → GenTraversableLike

def segmentLength(p: (T) ⇒ Boolean, from: Int): Int

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

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

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

p: предикат, используемый для проверки элементов
from: смещение начальной точки поиска
returns: длина самой длинной последовательности элементов, начинающейся с from и удовлетворяющей предикату

Definition Classes: ParSeqLike → GenSeqLike

def sequentially[S, That <: Parallel](b: (immutable.Seq[T]) ⇒ Parallelizable[S, That]): ParSeq[T]

Attributes: protected[this]
Definition Classes: ParIterableLike

def size: Int

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

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

возвращает: количество элементов в этом параллельном итерируемом объекте.

Классы-определения: ParSeqLike → GenTraversableLike → GenTraversableOnce

def sizeHintIfCheap: Int

Размер этой коллекции или итератора, если он может быть вычислен без больших затрат.

возвращает: количество элементов в этой коллекции или итераторе, или -1, если размер нельзя определить без больших затрат.

Атрибуты: protected[collection]
Классы-определения: GenTraversableOnce

def slice(unc_from: Int, unc_until: Int): ParSeq[T]

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

from <= indexOf(x) < until

unc_from: наименьший индекс для включения из этого параллельного итерируемого объекта.
unc_until: наименьший индекс для исключения из этого параллельного итерируемого объекта.
возвращает: параллельный итерируемый объект, содержащий элементы, большие или равные индексу from, и простирающийся до (но не включая) индекс until этого параллельного итерируемого объекта.

Классы-определения: ParIterableLike → GenTraversableLike

def span(pred: (T) ⇒ Boolean): (ParSeq[T], ParSeq[T])

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

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

pred: предикат, используемый для проверки элементов
возвращает: пара, состоящая из самого длинного префикса коллекции, для которого все элементы удовлетворяют pred, и остальная часть коллекции

Классы-определения: ParIterableLike → GenTraversableLike

def splitAt(n: Int): (ParSeq[T], ParSeq[T])

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

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

Классы-определения: ParIterableLike → GenTraversableLike

def startsWith[S](that: GenSeq[S], offset: Int): Boolean

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

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

S: тип элемента that параллельной последовательности
that: параллельная последовательность, для которой ищется эта последовательность
offset: начальное смещение для поиска
возвращает: true если существует последовательность that , начинающаяся с offset в этой последовательности, false в противном случае

Классы-определения: ParSeqLike → GenSeqLike

def startsWith[B](that: GenSeq[B]): Boolean

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

that: тестируемая последовательность
возвращает: true если у этой коллекции that в качестве префикса, false в противном случае.

Классы-определения: GenSeqLike

def stringPrefix: String

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

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

Классы-определения: ParSeq → ParIterable → GenTraversableLike

def sum: A

[use case]

Суммирует элементы этого набора.

returns: сумма всех элементов в этой изменяемой параллельной последовательности чисел типа Int. Вместо Int, может быть использован любой другой тип T с неявной реализацией Numeric[T] в качестве типа элементов изменяемой параллельной последовательности и типа результата sum. Примеры таких типов: Long, Float, Double, BigInt.

Definition Classes: ParIterableLike → GenTraversableOnce

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def tail: ParSeq[T]

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

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

returns: параллельное множество, состоящее из всех элементов этого параллельного итерируемого объекта, за исключением первого.

Definition Classes: ParIterableLike → GenTraversableLike
Исключения: UnsupportedOperationException, если параллельное множество пусто.

def take(n: Int): ParSeq[T]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def takeWhile(pred: (T) ⇒ Boolean): ParSeq[T]

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

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

pred: предикат для проверки элементов
returns: самая длинная префиксная часть этого параллельного набора элементов, удовлетворяющих предикату pred

Definition Classes: ParIterableLike → GenTraversableLike

implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]

Attributes: protected
Definition Classes: ParIterableLike

def tasksupport: TaskSupport

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

Definition Classes: ParIterableLike
См. также: scala.collection.parallel.TaskSupport

def tasksupport_=(ts: TaskSupport): Unit

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

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

Вот как можно изменить поддержку задач параллельного набора:

import scala.collection.parallel._
val pc = mutable.ParArray(1, 2, 3)
pc.tasksupport = new ForkJoinTaskSupport(
  new java.util.concurrent.ForkJoinPool(2))

Definition Classes: ParIterableLike
См. также: scala.collection.parallel.TaskSupport

def to[Col[_]]: Col[A]

[use case]

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

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

Col: Тип коллекции для создания.
returns: новая коллекция, содержащая все элементы этого изменяемого параллельного набора.

Definition Classes: ParIterableLike → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

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

Классы-определения: ParIterableLike → GenTraversableOnce

def toBuffer[U >: T]: Buffer[U]

Использует содержимое этой параллельной итерируемой последовательности для создания нового изменяемого буфера.

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

возвращает: буфер, содержащий все элементы этой параллельной итерируемой последовательности.

Классы-определения: ParIterableLike → GenTraversableOnce

def toIndexedSeq: immutable.IndexedSeq[T]

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

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

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

Классы-определения: ParIterableLike → GenTraversableOnce

def toIterable: ParIterable[T]

Преобразует эту параллельную итерируемую последовательность в коллекцию-итерируемую. Обратите внимание, что выбор целевого Iterable в этом реализации по умолчанию является ленивым, так как этот TraversableOnce может быть ленивым и невычисляемым (т.е. это может быть итератор, который можно проходить только один раз).

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

возвращает: Iterable содержащий все элементы этой параллельной итерируемой последовательности.

Классы-определения: ParIterable → ParIterableLike → GenTraversableOnce

def toIterator: scala.Iterator[T]

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

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

возвращает: итератор, содержащий все элементы этой параллельной итерируемой последовательности.

Классы-определения: ParIterableLike → GenTraversableOnce

def toList: List[T]

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

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

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

Классы-определения: ParIterableLike → GenTraversableOnce

def toMap[T, U]: collection.Map[T, U]

[use case]

Преобразует эту изменяемую параллельную последовательность в карту. Этот метод недоступен, если элементы не являются членами Tuple2, каждый ((T, U)) становится парой ключ-значение в карте. Повторяющиеся ключи будут перезаписаны более поздними ключами: если это неупорядоченная коллекция, ключ, который находится в результирующей карте, не определен.

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

возвращает: карта типа immutable.Map[T, U] содержащая все пары ключ/значение типа (T, U) этой изменяемой параллельной последовательности.

Классы-определения: ParIterableLike → GenTraversableOnce

def toParArray: ParArray[T]

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в CollectionsHaveToParArray[ParSeq[T], T] выполненным методом CollectionsHaveToParArray в scala.collection.parallel. Это преобразование будет выполняться только в том случае, если в области видимости имеется неявное значение типа (ParSeq[T]) ⇒ GenTraversableOnce[T].
Классы-определения: CollectionsHaveToParArray

def toParCollection[U >: T, That](cbf: () ⇒ Combiner[U, That]): That

Атрибуты: protected
Классы-определения: ParIterableLike

def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[T, (K, V)]): That

Атрибуты: protected
Классы определений: ParIterableLike

def toSeq: ParSeq[T]

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

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

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

Классы определений: ParSeq → ParIterable → ParSeqLike → ParIterableLike → GenSeqLike → GenTraversableOnce

def toSet[U >: T]: ParSet[U]

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

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

возвращает: множество, содержащее все элементы этого параллельного множества.

Классы определений: ParIterableLike → GenTraversableOnce

def toStream: Stream[T]

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

возвращает: поток, содержащий все элементы этого параллельного множества.

Классы определений: ParIterableLike → GenTraversableOnce

def toString(): String

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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

Классы определений: ParSeq → ParSeqLike → ParIterableLike → AnyRef → Any

def toTraversable: GenTraversable[T]

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

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

возвращает: множество, содержащее все элементы этого параллельного множества.

Классы определений: ParIterableLike → GenTraversableOnce

def toVector: Vector[T]

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

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

возвращает: вектор, содержащий все элементы этого параллельного множества.

Классы определений: ParIterableLike → GenTraversableOnce

def transpose[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): ParSeq[ParSeq[B]]

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

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

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

B: тип элементов каждой коллекции.
asTraversable: явное преобразование, которое утверждает, что тип элемента этой коллекции является Traversable.
возвращает: двумерная коллекция коллекций, где n-я строка - это n-й столбец этой коллекции.

Классы определений: GenericTraversableTemplate
Аннотации: @migration
Миграция: (Изменено в версии 2.9.0) transpose выбрасывает IllegalArgumentException если коллекции не имеют одинаковый размер.
Исключения: IllegalArgumentException, если все коллекции в этой коллекции не имеют одинаковый размер.

def union(that: GenSeq[T]): mutable.ParSeq[T]

[сценарий использования]

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

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

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

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

Определяющие классы: GenSeqLike

def unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (ParSeq[A1], ParSeq[A2])

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

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

A1: тип первой половины пар элементов
A2: тип второй половины пар элементов
asPair: явное преобразование, которое утверждает, что тип элементов этой коллекции является парой.
возвращает: пара коллекций, содержащая первую, соответственно вторую половину каждой пары элементов этой коллекции.

Определяющие классы: GenericTraversableTemplate

def unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (ParSeq[A1], ParSeq[A2], ParSeq[A3])

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

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

A1: тип первого члена троек элементов
A2: тип второго члена троек элементов
A3: тип третьего члена троек элементов
asTriple: явное преобразование, которое утверждает, что тип элементов этой коллекции является тройкой.
возвращает: тройку коллекций, содержащую первый, второй, соответственно третий член каждой тройки элементов этой коллекции.

Определяющие классы: GenericTraversableTemplate

def updated(index: Int, elem: A): mutable.ParSeq[A]

[сценарий использования]

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

index: позиция замены
elem: элемент замены
возвращает: копию этой изменяемой параллельной последовательности с элементом в позиции index заменённым на elem.

Определяющие классы: ParSeqLike → GenSeqLike

final def wait(): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... ) @native()

def withFilter(pred: (T) ⇒ Boolean): ParSeq[T]

Определяющие классы: ParIterableLike

def wrap[R](body: ⇒ R): NonDivisible[R]

Атрибуты: protected
Определяющие классы: ParIterableLike

def zip[B](that: GenIterable[B]): mutable.ParSeq[(A, B)]

[use case]

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

B: тип второй половины возвращаемых пар
that: Итерируемая коллекция, предоставляющая вторую половину каждой пары результата
returns: новая изменяемая параллельная последовательность, содержащая пары, состоящие из соответствующих элементов этой изменяемой параллельной последовательности и that. Длина возвращаемой коллекции — минимальное из длин этой изменяемой параллельной последовательности и that.

Definition Classes: ParSeqLike → ParIterableLike → GenIterableLike

def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): mutable.ParSeq[(A, B)]

[use case]

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

B: тип второй половины возвращаемых пар
that: Итерируемая коллекция, предоставляющая вторую половину каждой пары результата
thisElem: элемент, используемый для заполнения результата, если эта изменяемая параллельная последовательность короче, чем that.
thatElem: элемент, используемый для заполнения результата, если that короче, чем эта изменяемая параллельная последовательность.
returns: новая изменяемая параллельная последовательность, содержащая пары, состоящие из соответствующих элементов этой изменяемой параллельной последовательности и that. Длина возвращаемой коллекции — максимальное из длин этой изменяемой параллельной последовательности и that. Если эта изменяемая параллельная последовательность короче that, значения thisElem используются для дополнения результата. Если that короче этой изменяемой параллельной последовательности, значения thatElem используются для дополнения результата.

Definition Classes: ParIterableLike → GenIterableLike

def zipWithIndex: mutable.ParSeq[(A, Int)]

[use case]

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

returns: Новая изменяемая параллельная последовательность, содержащая пары, состоящие из всех элементов этой изменяемой параллельной последовательности, спаренных с их индексом. Индексы начинаются с 0.

Definition Classes: ParIterableLike → GenIterableLike

def →[B](y: B): (ParSeq[T], B)

Неявный: Этот член добавлен неявным преобразованием из ParSeq[T] в ArrowAssoc[ParSeq[T]], выполненное методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/parallel/immutable/ParSeq.html