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

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

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

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

Self Type: ParSeq[T]
Source: 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[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
Определяющие классы: 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)

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: mutable.Seq[T]

Определение классов: ParSeq → ParIterable → ParIterableLike → GenSeq → GenIterable → GenTraversable → GenSeqLike → Parallelizable → GenTraversableOnce

abstract def splitter: SeqSplitter[T]

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

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

Атрибуты: protected[parallel]
Определение классов: ParSeqLike → ParIterableLike

abstract def update(i: Int, elem: T): Unit

Конкретные члены значения

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): 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): 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: добавляемый элемент
возвращает: новая изменяемая параллельная последовательность, состоящая из всех элементов этой изменяемой параллельной последовательности, за которыми следуют 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

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

возвращает

результат вставки 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).

возвращает: 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(_), _ ++ _)

Еще один пример - вычисление геометрического среднего из набора чисел double (обычно для этого требуются большие числа double).

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

[use case]

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

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

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

Definition Classes: ParSeqLike → GenSeqLike

def distinct: ParSeq[T]

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

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

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

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

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

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

def equals(that: Any): Boolean

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def flatten[B]: ParSeq[B]

[use case]

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

B: тип элементов каждой коллекции traversable.
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)...))

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): immutable.ParMap[K, ParSeq[T]]

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

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

K

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

f

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

возвращает

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

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

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

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

def hasDefiniteSize: Boolean

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

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

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

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

def hashCode(): Int

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

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

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

def head: T

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

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

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

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

def headOption: Option[T]

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

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

возвращает: первый элемент этого параллельного iterable, если оно не пусто, 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]): 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

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

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

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): ParSeq[B]

[use case]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def max: A

[use case]

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

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

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

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

[use case]

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

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

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

def min: A

[use case]

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

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

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

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

[use case]

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

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

Definition Classes: ParIterableLike → GenTraversableOnce
Исключения: 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): 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): 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: Результат применения оператора 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: необязательное значение, содержащее результат 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: Необязательное значение, содержащее результат применения оператора 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: вариант, содержащий результат 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): 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): 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: (mutable.Seq[T]) ⇒ Parallelizable[S, That]): ParSeq[T]

Attributes: protected[this]
Definition Classes: ParIterableLike

def size: Int

Размер этой параллельной итерируемой последовательности.

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

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

Definition Classes: 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

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

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]

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

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

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

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

Definition Classes: AnyRef

def tail: ParSeq[T]

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

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

Definition Classes: ParIterableLike → GenTraversableLike
Exceptions thrown: 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
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: итерируемое множество, содержащее все элементы этого параллельного итерируемого множества.

Definition Classes: ParIterable → 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]

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

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

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

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

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

def toSeq: ParSeq[T]

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

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

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

Definition Classes: ParSeq → ParSeqLike → ParIterable → ParIterableLike → GenSeqLike → GenTraversableOnce

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toStream: Stream[T]

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toString(): String

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

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

Definition Classes: ParSeq → ParSeqLike → ParIterableLike → AnyRef → Any

def toTraversable: GenTraversable[T]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toVector: Vector[T]

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

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

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

Definition Classes: 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.
returns: двумерная коллекция коллекций, в которой n-я строка является n-м столбцом этой коллекции.

Definition Classes: GenericTraversableTemplate
Annotations: @migration
Migration: (Изменено в версии 2.9.0) transpose вызывает IllegalArgumentException если размеры коллекций не совпадают.
Exceptions thrown: IllegalArgumentException если все коллекции в этой коллекции не имеют одинаковый размер.

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

[use case]

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

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

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

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

Definition Classes: 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: явное преобразование, которое утверждает, что тип элементов этого множества — пара.
returns: пара множеств, содержащая первую и соответственно вторую половину каждой пары элементов этого множества.

Definition Classes: 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: явное преобразование, которое утверждает, что тип элементов этого множества — тройка.
returns: тройка множеств, содержащая первый, второй и соответственно третий член каждой тройки элементов этого множества.

Definition Classes: GenericTraversableTemplate

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

[use case]

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

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

Definition Classes: ParSeqLike → GenSeqLike

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

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

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

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

Definition Classes: ParIterableLike

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

Attributes: protected
Definition Classes: ParIterableLike

def zip[B](that: GenIterable[B]): 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): ParSeq[(A, B)]

[use case]

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

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

Definition Classes: ParIterableLike → GenIterableLike

def zipWithIndex: 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/mutable/ParSeq.html