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

trait ParSeqLike[+T, +Repr <: ParSeq[T], +Sequential <: scala.Seq[T] with SeqLike[T, Sequential]] extends GenSeqLike[T, Repr] with ParIterableLike[T, Repr, Sequential]

Шаблонный трейт для последовательностей типа ParSeq[T], представляющих параллельные последовательности с типом элементов T.

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

Этот трейт определяет новую, более общую операцию split и переопределяет операцию split трейта ParallelIterable с использованием новой операции split.

T: тип элементов, содержащихся в этом наборе
Repr: тип фактического набора, содержащего элементы
Sequential: тип последовательной версии этого параллельного набора

Self Type: ParSeqLike[T, Repr, Sequential]
Source: ParSeqLike.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[Единица, CopyToArray[U, This]]

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

класс Count extends Accessor[Целое, 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[Unit, 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

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

Атрибуты: protected[this]

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

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

Атрибуты: protected

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

Атрибуты: protected[this]

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

Атрибуты: protected[this]

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

Атрибуты: protected[this]

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

Атрибуты: protected[this]

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

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

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

Атрибуты: protected[this]

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

Атрибуты: protected[this]

тип SuperParIterator = IterableSplitter[T]

Атрибуты: protected[this]

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

Атрибуты: protected

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

Атрибуты: protected[this]

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

Атрибуты: protected[this]

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

abstract def apply(idx: 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: Индекс для выбора.
returns: элемент этой общей последовательности по индексу idx, где 0 обозначает первый элемент.

Definition Classes: GenSeqLike
Исключения: IndexOutOfBoundsException если idx не удовлетворяет 0 <= idx < length.

abstract def length: Int

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

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

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

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

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

abstract def newCombiner: Combiner[T, Repr]

Атрибуты: protected[this]
Definition Classes: HasNewCombiner

abstract def seq: Sequential

Definition Classes: ParIterableLike → Parallelizable → GenTraversableOnce

abstract def splitter: SeqSplitter[T]

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

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

Атрибуты: protected[parallel]
Definition Classes: ParSeqLike → ParIterableLike

abstract def stringPrefix: String

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

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

Definition Classes: GenTraversableLike

Члены-значения Concrete

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

Implicit: Этот член добавляется неявным преобразованием из ParSeqLike[T, Repr, Sequential] в any2stringadd[ParSeqLike[T, Repr, Sequential]] выполняемое методом any2stringadd в scala.Predef.
Definition Classes: any2stringadd

def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[Repr, 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): ParIterable[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): (ParSeqLike[T, Repr, Sequential], B)

Implicit: Этот член добавляется неявным преобразованием из ParSeqLike[T, Repr, Sequential] в ArrowAssoc[ParSeqLike[T, Repr, Sequential]] выполняемое методом 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

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

возвращает

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

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

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

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

def :+(elem: A): ParIterable[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: добавляемый элемент
возвращает: новый параллельный итерируемый объект, содержащий все элементы этого параллельного итерируемого объекта, за которыми следует elem.

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

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

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

Примечание: :\ — это альтернативная синтаксическая конструкция для foldRight; xs :\ z эквивалентно xs foldRight z.

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

Примеры:

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

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

возвращает

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

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

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

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

final def ==(arg0: Any): Boolean

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

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

Определяющие классы: 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(_), _ ++ _)

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

S: тип аккумулированных результатов
z: начальное значение для аккумулированного результата раздела — обычно это нейтральный элемент для оператора seqop (например, Nil для конкатенации списков или 0 для суммирования) и может быть вычислено более одного раза
seqop: оператор, используемый для аккумулирования результатов в рамках раздела
combop: ассоциативный оператор, используемый для объединения результатов из разных разделов

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

final def asInstanceOf[T0]: T0

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

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

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

Определяющие классы: Any
Исключения: ClassCastException, если объект-получатель не является экземпляром стирания типа T0.

def bf2seq[S, That](bf: CanBuildFrom[Repr, S, That]): CanBuildFrom[Sequential, S, That]

Attributes: protected[this]
Definition Classes: ParIterableLike

implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]

Attributes: protected
Definition Classes: ParIterableLike

def canEqual(other: Any): Boolean

Definition Classes: ParIterableLike

def clone(): AnyRef

Создать копию объекта-приёмника.

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

возвращает: копию объекта-приёмника.

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( ... ) @native()
Примечание: не указано SLS как член AnyRef

def collect[B](pf: PartialFunction[A, B]): ParIterable[B]

[use case]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

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

Attributes: protected[this]
Definition Classes: ParIterableLike

def combinerFactory: CombinerFactory[T, Repr]

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

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

Attributes: protected[this]
Definition Classes: ParIterableLike

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

[use case]

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

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

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

Definition Classes: 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: предикат проверки, связывающий элементы из обеих последовательностей
returns: true если обе параллельные последовательности имеют одинаковую длину и p(x, y) является true для всех соответствующих элементов x этого параллельного итерируемого объекта и y из that, в противном случае false

Definition Classes: ParSeqLike → GenSeqLike

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

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

p: предикат, используемый для проверки элементов.
returns: количество элементов, удовлетворяющих предикату 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]): ParIterable[A]

[use case]

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

def distinct: Repr

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

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

Attributes: protected[this]

def drop(n: Int): Repr

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def dropWhile(pred: (T) ⇒ Boolean): Repr

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

Этот метод будет использовать 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: (ParSeqLike[T, Repr, Sequential]) ⇒ Boolean, msg: ⇒ Any): ParSeqLike[T, Repr, Sequential]

Implicit: Этот член добавлен неявным преобразованием из ParSeqLike[T, Repr, Sequential] в Ensuring[ParSeqLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (ParSeqLike[T, Repr, Sequential]) ⇒ Boolean): ParSeqLike[T, Repr, Sequential]

Implicit: Этот член добавлен неявным преобразованием из ParSeqLike[T, Repr, Sequential] в Ensuring[ParSeqLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): ParSeqLike[T, Repr, Sequential]

Implicit: Этот член добавлен неявным преобразованием из ParSeqLike[T, Repr, Sequential] в Ensuring[ParSeqLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean): ParSeqLike[T, Repr, Sequential]

Неявный: Этот член добавлен с помощью неявного преобразования из ParSeqLike[T, Repr, Sequential] в Ensuring[ParSeqLike[T, Repr, Sequential]] через метод Ensuring в scala.Predef.
Определяющие классы: Ensuring

final def eq(arg0: AnyRef): Boolean

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

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

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

def equals(that: Any): Boolean

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

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

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

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

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

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

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

def filter(pred: (T) ⇒ Boolean): Repr

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

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

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

def filterNot(pred: (T) ⇒ Boolean): Repr

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

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

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

def finalize(): Unit

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

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

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

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

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

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

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

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

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): ParIterable[B]

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

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

Например:

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

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

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

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

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

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

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

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

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

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

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

z

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

op

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

возвращает

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

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

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

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

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

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

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

z

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

op

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

возвращает

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

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

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

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

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

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

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

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

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

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

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

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

def formatted(fmtstr: String): String

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

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

final def getClass(): Class[_]

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

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

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

def groupBy[K](f: (T) ⇒ K): immutable.ParMap[K, Repr]

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

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

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: начальный индекс
возвращает: индекс >= from первого элемента этой параллельной итерируемой последовательности, который равен (определяется по ==) elem, или -1, если такового нет.

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

def indexOf(elem: T): Int

[use case]

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

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

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

Определяющие классы: 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: Repr

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

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

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

def initTaskSupport(): Unit

Attributes: protected
Definition Classes: ParIterableLike

def intersect(that: scala.Seq[T]): ParIterable[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): ParIterable[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 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

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

Классы-определения: AnyRef
Аннотации: @native()
Примечание: не указано SLS как член AnyRef

def padTo(len: Int, elem: A): ParIterable[A]

[use case]

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

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

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

def par: Repr

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

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

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

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

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

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

def parCombiner: Combiner[T, Repr]

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

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

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

def partition(pred: (T) ⇒ Boolean): (Repr, Repr)

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

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

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

def patch(from: Int, that: GenSeq[A], replaced: Int): ParIterable[A]

[use case]

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

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

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

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

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

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

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

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

def product: A

[use case]

Умножает элементы этого набора.

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

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

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

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce
Исключения: 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]

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

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

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

U: Параметр типа для бинарного оператора, являющийся супертипом T.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Значение option, содержащее результат применения оператора уменьшения 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
Исключения: UnsupportedOperationException если это параллельное итерируемое пусто.

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def repr: Repr

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: Repr

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

def reverseMap[B](f: (A) ⇒ B): ParIterable[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): ParIterable[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[Repr, 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[Repr, 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: (Sequential) ⇒ Parallelizable[S, That]): Repr

Attributes: protected[this]
Definition Classes: ParIterableLike

def size: Int

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

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

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

Definition Classes: ParSeqLike → GenTraversableLike → GenTraversableOnce

def sizeHintIfCheap: Int

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

returns: количество элементов в этой коллекции или итераторе, или -1, если размер не может быть определён дёшево

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(unc_from: Int, unc_until: Int): Repr

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

from <= indexOf(x) < until

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def span(pred: (T) ⇒ Boolean): (Repr, Repr)

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def splitAt(n: Int): (Repr, Repr)

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

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

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

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

Definition Classes: GenSeqLike

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: Repr

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

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

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

def take(n: Int): Repr

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def takeWhile(pred: (T) ⇒ Boolean): Repr

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

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

Атрибуты: protected
Definition Classes: ParIterableLike

def tasksupport: TaskSupport

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

Definition Classes: ParIterableLike
See also: 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
See also: scala.collection.parallel.TaskSupport

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

[use case]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toIndexedSeq: immutable.IndexedSeq[T]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toIterable: ParIterable[T]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toIterator: scala.Iterator[T]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toList: List[T]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toParArray: ParArray[T]

Неявный: Этот член добавлен неявным преобразованием из ParSeqLike[T, Repr, Sequential] в CollectionsHaveToParArray[ParSeqLike[T, Repr, Sequential], T] с помощью метода CollectionsHaveToParArray в scala.collection.parallel. Это преобразование произойдёт только в том случае, если в области видимости имеется неявное значение типа (ParSeqLike[T, Repr, Sequential]) ⇒ 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 может быть ленивым и невычисленным.

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

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

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

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

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

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

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

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

def toStream: Stream[T]

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

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

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

def toString(): String

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

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

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

def toTraversable: GenTraversable[T]

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

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

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

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

def toVector: Vector[T]

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

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

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

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

def union(that: GenSeq[T]): ParIterable[T]

[use case]

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

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

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

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

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

def updated(index: Int, elem: A): ParIterable[A]

[use case]

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

index: Позиция замены.
elem: Заменяющий элемент.
returns: Копия этого параллельного итерируемого объекта с элементом на позиции 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): Repr

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

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

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

def zip[B](that: GenIterable[B]): ParIterable[(A, B)]

[use case]

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

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

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

def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): ParIterable[(A, B)]

[use case]

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

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

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

Definition Classes: ParIterableLike → GenIterableLike

def zipWithIndex: ParIterable[(A, Int)]

[use case]

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

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

Definition Classes: ParIterableLike → GenIterableLike

def →[B](y: B): (ParSeqLike[T, Repr, Sequential], B)

Неявный: Этот член добавлен с помощью неявного преобразования из ParSeqLike[T, Repr, Sequential] в ArrowAssoc[ParSeqLike[T, Repr, Sequential]] , выполненного методом 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/ParSeqLike.html