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

Компонент объект ParHashMap

класс ParHashMap[K, +V] extends ParMap[K, V] with GenericParMapTemplate[K, V, ParHashMap] with ParMapLike[K, V, ParHashMap[K, V], HashMap[K, V]] with Serializable

Неизменяемая параллельная карта хешей, основанная на хеш-деревьях.

Это базовый трейт для параллельных коллекций Scala. Он определяет поведение, общее для всех параллельных коллекций. Конкретные параллельные коллекции должны унаследовать этот трейт и ParIterable если они хотят определить специфические фабрики комбинирования.

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

Все параллельные операции реализованы как задачи в этом трейте. Задачи опираются на понятие разделителей, которые расширяют итераторы. Каждая параллельная коллекция определяет:

def splitter: IterableSplitter[T]

который возвращает экземпляр IterableSplitter[T], который является подтипом Splitter[T]. У разделителей есть метод remaining для проверки оставшегося количества элементов и метод split, который определен разделителями. Метод split делит разделителей, которые перебираются, на непересекающиеся подмножества:

def split: Seq[Splitter]

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

Задачи планируются для выполнения с помощью объекта scala.collection.parallel.TaskSupport, который может быть изменён через tasksupport установщик коллекции.

Метод newCombiner создаёт новый комбинировщик. Комбинировщики представляют собой расширение сборщиков. Они предоставляют метод combine, который объединяет два комбинировщика и возвращает комбинировщик, содержащий элементы обоих комбинировщиков. Этот метод может быть реализован путём агрессивного копирования всех элементов в новый комбинировщик или путём ленивой привязки их результатов. Рекомендуется избегать копирования всех элементов по соображениям производительности, хотя эта стоимость может быть незначительной в зависимости от конкретного случая. Стандартные комбинировщики параллельных коллекций избегают копирования при слиянии результатов, полагаясь либо на двухэтапную ленивую конструкцию, либо на свойства конкретной структуры данных.

Методы:

def seq: Sequential
def par: Repr

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

Комбинация методов toMap, toSeq или toSet вместе с par и seq — гибкий способ переключения между различными типами коллекций.

Так как этот трейт расширяет трейт GenIterable, методы, такие как size, также должны быть реализованы в конкретных коллекциях, в то время как iterator по умолчанию перенаправляет splitter.

Каждая параллельная коллекция привязана к определённому пулу fork/join, в котором хранятся спящие потоки-рабочие. Пул fork/join содержит другую информацию, такую как уровень параллелизма, то есть количество используемых процессоров. При создании коллекции ей назначается пул fork/join по умолчанию, найденный в scala.parallel пакете.

Параллельные коллекции не обязательно упорядочены в отношении операции foreach (см. Traversable). Параллельные последовательности имеют чётко определённый порядок для итераторов — создание итератора и линейное прохождение элементов всегда дадут один и тот же порядок. Однако массовые операции, такие как foreach, map или filter, всегда происходят в неопределённом порядке для всех параллельных коллекций.

Существующие реализации параллельных коллекций предоставляют жёсткие параллельные итераторы. Жесткие параллельные итераторы знают количество элементов, которые им ещё предстоит пройти. Также можно предоставить нежёсткие параллельные итераторы, которые не знают количество оставшихся элементов. Для этого новая реализация коллекции должна переопределить isStrictSplitterCollection на false. Это сделает некоторые операции недоступными.

Чтобы создать новую параллельную коллекцию, расширьте трейт ParIterable, и реализуйте size, splitter, newCombiner и seq. Необходимость неявного фабричного комбинирования требует расширения этого трейта, а также предоставления объекта-компаньона, как и в случае с обычными коллекциями.

Метод size реализован как операция постоянного времени для параллельных коллекций, и операции параллельных коллекций полагаются на это предположение.

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

K: тип ключа карты
V: тип значения карты

Тип самого себя: ParHashMap[K, V]
Аннотации: @SerialVersionUID()
Источник: ParHashMap.scala
С: 2.9
См. также: Обзор библиотеки параллельных коллекций Scala раздел о параллельных хеш-деревьях для получения дополнительной информации.

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

Конструкторы экземпляров

новый ParHashMap()

END_OF_DOCUMENT_MARKER

Члены типов

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

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

R: тип результата этого метода (R для результата).
Tp: тип представления текущей задачи.

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

класс 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

abstract class SeqComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

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

Attributes: protected[this]
Definition Classes: ParIterableLike

trait SignallingOps[PI <: DelegatedSignalling] extends AnyRef

Definition Classes: ParIterableLike

class Slice[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]

Attributes: protected[this]
Definition Classes: ParIterableLike

class Span[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]

Attributes: protected[this]
Definition Classes: ParIterableLike

class SplitAt[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]

Attributes: protected[this]
Definition Classes: ParIterableLike

trait StrictSplitterCheckTask[R, Tp] extends Task[R, Tp]

Attributes: protected
Definition Classes: ParIterableLike

class Sum[U >: T] extends Accessor[U, Sum[U]]

Attributes: protected[this]
Definition Classes: ParIterableLike

class Take[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]

Attributes: protected[this]
Definition Classes: 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

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

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

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

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

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

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

класс DefaultKeySet extends ParSet[K]

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

класс DefaultValuesIterable extends ParIterable[V]

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

класс ParHashMapIterator extends IterableSplitter[(K, V)]

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

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

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

final def !=(arg0: Any): Boolean

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

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

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

final def ##(): Int

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

возвращает: хэш-значение, согласованное с ==

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

def +[U >: V](kv: (K, U)): ParHashMap[K, U]

Определяющие классы: ParHashMap → ParMap → ParMap → GenMapLike

def ++[U >: (K, V), That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParHashMap[K, V], U, That]): That

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

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

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

def -(k: K): ParHashMap[K, V]

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

def ->[B](y: B): (ParHashMap[K, V], B)

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

def /:[S](z: S)(op: (S, (K, V)) ⇒ 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 :\[S](z: S)(op: ((K, V), S) ⇒ S): S

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

Примечание: :\ — это альтернативная запись для foldRight; xs :\ z — то же самое, что и xs foldRight z.

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

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

Примеры:

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

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

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

z

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

op

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

returns

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

final def ==(arg0: Any): Boolean

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

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

Definition Classes: AnyRef → Any

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

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

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

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

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

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

def apply(key: K): V

Definition Classes: ParMapLike → GenMapLike

final def asInstanceOf[T0]: T0

def bf2seq[S, That](bf: CanBuildFrom[ParHashMap[K, V], S, That]): CanBuildFrom[HashMap[K, V], S, That]

Attributes: protected[this]
Definition Classes: ParIterableLike

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

[случаи применения]

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

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

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

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

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

def combinerFactory: CombinerFactory[(K, V), ParHashMap[K, V]]

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

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

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

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

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

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

def contains(key: K): Boolean

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

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

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

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 count(p: ((K, V)) ⇒ Boolean): Int

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def debugBuffer: ArrayBuffer[String]

Definition Classes: ParIterableLike

def default(key: K): V

Definition Classes: ParMapLike → GenMapLike

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

Attributes: protected
Definition Classes: ParIterableLike

def drop(n: Int): ParHashMap[K, V]

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def dropWhile(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def empty: ParHashMap[K, V]

Definition Classes: ParHashMap → ParMap → ParMap → ParMapLike

def ensuring(cond: (ParHashMap[K, V]) ⇒ Boolean, msg: ⇒ Any): ParHashMap[K, V]

Неявный: Этот член добавлен неявным преобразованием из ParHashMap[K, V] в Ensuring[ParHashMap[K, V]], выполненным методом Ensuring в scala.Predef.
Определяющие классы: Ensuring

def ensuring(cond: (ParHashMap[K, V]) ⇒ Boolean): ParHashMap[K, V]

Неявный: Этот член добавлен неявным преобразованием из ParHashMap[K, V] в Ensuring[ParHashMap[K, V]], выполненным методом Ensuring в scala.Predef.
Определяющие классы: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): ParHashMap[K, V]

Неявный: Этот член добавлен неявным преобразованием из ParHashMap[K, V] в Ensuring[ParHashMap[K, V]], выполненным методом Ensuring в scala.Predef.
Определяющие классы: Ensuring

def ensuring(cond: Boolean): ParHashMap[K, V]

Неявный: Этот член добавлен неявным преобразованием из ParHashMap[K, V] в Ensuring[ParHashMap[K, V]], выполненным методом 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

Структурно сравнивает два отображения; т.е., проверяет, содержатся ли все отображения, содержащиеся в этом отображении, также в другом отображении, и наоборот.

that: другое отображение
возвращает: true если оба отображения содержат точно такие же отображения, false в противном случае.

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

def exists(p: ((K, V)) ⇒ Boolean): Boolean

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def filter(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def filterKeys(p: (K) ⇒ Boolean): parallel.ParMap[K, V]

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

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

Definition Classes: ParMapLike → GenMapLike

def filterNot(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def finalize(): Unit

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

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

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )
Note: не указано SLS как члена AnyRef

def find(p: ((K, V)) ⇒ Boolean): Option[(K, V)]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

[use case]

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующей коллекции определяется статическим типом неизменяемого параллельного хэш-карты. Это может иногда приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

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

Definition Classes: ParIterableLike → GenTraversableLike

def flatten[B]: ParHashMap[B]

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

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

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

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

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

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

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

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

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

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

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

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

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

z

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

op

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

возвращает

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

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

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

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

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

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

z

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

op

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

возвращает

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

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

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

def forall(p: ((K, V)) ⇒ Boolean): Boolean

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

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

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

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

def foreach[U](f: ((K, V)) ⇒ U): Unit

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

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

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

def formatted(fmtstr: String): String

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

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

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

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

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

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

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

def genericMapCombiner[P, Q]: Combiner[(P, Q), ParHashMap[P, Q]]

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

def get(k: K): Option[V]

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

final def getClass(): Class[_]

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

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

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

def getOrElse(key: K, default: ⇒ V): V

[use case]

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

key: ключ.
default: вычисление, которое возвращает значение по умолчанию в случае, если в карте нет привязки к key.
возвращает: значение, связанное с key, если оно существует, в противном случае результат вычисления default.

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

def groupBy[K](f: ((K, V)) ⇒ K): ParMap[K, ParHashMap[K, V]]

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

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

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

Definition Classes: GenMapLike → AnyRef → Any

def head: (K, V)

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike
Исключения: NoSuchElementException, если параллельный итерируемый объект пустой.

def headOption: Option[(K, V)]

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def init: ParHashMap[K, V]

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

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

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

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

def initTaskSupport(): Unit

Attributes: protected
Definition Classes: ParIterableLike

def isDefinedAt(key: K): Boolean

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

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

Definition Classes: ParMapLike → GenMapLike

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: Splitter[(K, V)]

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

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

возвращает: итератор разбиений

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

def keySet: parallel.ParSet[K]

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

def keys: parallel.ParIterable[K]

Собирает все ключи этой карты в итерируемую коллекцию.

возвращает: ключи этой карты в виде итерируемого объекта.

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

def keysIterator: IterableSplitter[K]

Создаёт итератор для всех ключей.

возвращает: итератор по всем ключам.

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

def last: (K, V)

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

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

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

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

def lastOption: Option[(K, V)]

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

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

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

def map[B](f: (A) ⇒ B): ParHashMap[B]

[use case]

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

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

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

def mapCompanion: GenericParMapCompanion[ParHashMap]

Определяющие классы: ParHashMap → ParMap → ParMap → GenericParMapTemplate

def mapValues[S](f: (V) ⇒ S): parallel.ParMap[K, S]

Преобразует эту карту, применяя функцию к каждому полученному значению.

f: функция, используемая для преобразования значений этой карты.
возвращает: представление карты, которая сопоставляет каждый ключ этой карты с f(this(key)). Результирующая карта оборачивает исходную карту без копирования каких-либо элементов.

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

def max: A

[use case]

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

возвращает: наибольший элемент этой неизменяемой параллельной хэш-карты.

Определяющие классы: 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[(K, V), ParIterable[(K, V)]]

Библиотека для построения экземпляров типа Traversable[A]

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

def newCombiner: HashMapCombiner[K, V]

Attributes: protected[this]
Definition Classes: ParHashMap → GenericParMapTemplate → 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 par: ParHashMap[K, V]

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

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

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

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

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

Definition Classes: ParIterableLike → CustomParallelizable → Parallelizable

def parCombiner: Combiner[(K, V), ParHashMap[K, V]]

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

returns: комбинируемый для параллельной коллекции типа ParRepr

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

def partition(pred: ((K, V)) ⇒ Boolean): (ParHashMap[K, V], ParHashMap[K, V])

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def product: A

[use case]

Произведение элементов этой коллекции.

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

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

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

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

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

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

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

Definition Classes: ParIterableLike

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def reduceRight[U >: (K, V)](op: ((K, V), 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 >: (K, V)](op: ((K, V), U) ⇒ U): Option[U]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def repr: ParHashMap[K, V]

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: ParHashMap → ParIterableLike

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

[use case]

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

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

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

Definition Classes: ParIterableLike → GenIterableLike

def scan(z: (K, V))(op: ((K, V), (K, V)) ⇒ (K, V)): ParHashMap[(K, V)]

[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, (K, V)) ⇒ S)(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def scanRight[S, That](z: S)(op: ((K, V), S) ⇒ S)(implicit bf: CanBuildFrom[ParHashMap[K, V], S, That]): That

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

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

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

Пример:

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def seq: HashMap[K, V]

Definition Classes: ParHashMap → ParIterableLike → GenMap → GenIterable → GenTraversable → GenMapLike → Parallelizable → GenTraversableOnce

def sequentially[S, That <: Parallel](b: (HashMap[K, V]) ⇒ Parallelizable[S, That]): ParHashMap[K, V]

Attributes: protected[this]
Definition Classes: ParIterableLike

def size: Int

Размер этой неизменяемой параллельной карты хэш.

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

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

Definition Classes: ParHashMap → GenTraversableLike → GenTraversableOnce

def sizeHintIfCheap: Int

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

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

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(unc_from: Int, unc_until: Int): ParHashMap[K, V]

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

from <= indexOf(x) < until

unc_from: наименьший индекс, включаемый из этой параллельной итерируемой коллекции.
unc_until: наименьший индекс, ИСКЛЮЧАЕМЫЙ из этой параллельной итерируемой коллекции.
возвращает: параллельная итерируемая коллекция, содержащая элементы, большие или равные индексу from, и простирающиеся до (но не включая) индекса until этой параллельной итерируемой коллекции.

Definition Classes: ParIterableLike → GenTraversableLike

def span(pred: ((K, V)) ⇒ Boolean): (ParHashMap[K, V], ParHashMap[K, V])

Разделяет эту параллельную итерируемую коллекцию на пару префикс/суффикс в соответствии с предикатом.

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

Definition Classes: ParIterableLike → GenTraversableLike

def splitAt(n: Int): (ParHashMap[K, V], ParHashMap[K, V])

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

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

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

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

def splitter: IterableSplitter[(K, V)]

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

возвращает: параллельный итератор

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

def stringPrefix: String

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

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

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

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

def tail: ParHashMap[K, V]

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

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

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

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

def take(n: Int): ParHashMap[K, V]

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

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

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

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

def takeWhile(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

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

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

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

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

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

Атрибуты: protected
Определяющие классы: 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 >: (K, V)]: Buffer[U]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toIndexedSeq: immutable.IndexedSeq[(K, V)]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toIterable: ParIterable[(K, V)]

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

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

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

Definition Classes: ParIterable → ParIterableLike → GenTraversableOnce

def toIterator: scala.Iterator[(K, V)]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toList: List[(K, V)]

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

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

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: ParMap → ParIterableLike → GenTraversableOnce

def toParArray: ParArray[T]

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

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

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

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

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

def toSeq: ParSeq[(K, V)]

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

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

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

Definition Classes: ParIterable → ParIterableLike → GenTraversableOnce

def toSet[U >: (K, V)]: ParSet[U]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toStream: Stream[(K, V)]

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toString(): String

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

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

Definition Classes: ParIterableLike → AnyRef → Any

def toTraversable: GenTraversable[(K, V)]

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

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

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

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

def toVector: Vector[(K, V)]

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

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

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

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

def transpose[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): ParIterable[ParIterable[B]]

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

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

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

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

def unzip[A1, A2](implicit asPair: ((K, V)) ⇒ (A1, A2)): (ParIterable[A1], ParIterable[A2])

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

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

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

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

def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) ⇒ (A1, A2, A3)): (ParIterable[A1], ParIterable[A2], ParIterable[A3])

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

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

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

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

def updated[U >: V](key: K, value: U): ParMap[K, U]

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

def values: parallel.ParIterable[V]

Собирает все значения этой карты в итерируемую коллекцию.

возвращает: значения этой карты в виде итерируемого множества.

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

def valuesIterator: IterableSplitter[V]

Создаёт итератор для всех значений в этом отображении.

возвращает: итератор по всем значениям, связанным с каким-либо ключом в этом отображении.

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

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 withDefault[U >: V](d: (K) ⇒ U): ParMap[K, U]

Такое же отображение с заданной функцией по умолчанию. Примечание: get, contains, iterator, keys, и т. д. не изменяются withDefault.

Вызов методов преобразования (например, map) не сохранит значение по умолчанию.

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

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

def withDefaultValue[U >: V](d: U): ParMap[K, U]

То же отображение с заданным значением по умолчанию.

Вызов методов преобразования (например, map) не сохранит значение по умолчанию.

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

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

def withFilter(pred: ((K, V)) ⇒ Boolean): ParHashMap[K, V]

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

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

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

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

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

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

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

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

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

[use case]

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

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

Definition Classes: ParIterableLike → GenIterableLike

def zipWithIndex: ParHashMap[(A, Int)]

[use case]

Объединяет эту неизменяемую параллельную хеш-таблицу с её индексами.

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

Definition Classes: ParIterableLike → GenIterableLike

def →[B](y: B): (ParHashMap[K, V], B)

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

Затенённые неявные члены-значения

def +(other: String): String

Неявный

Этот член добавлен неявным преобразованием из ParHashMap[K, V] в any2stringadd[ParHashMap[K, V]], выполненным методом any2stringadd в scala.Predef.

Затенение

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

(parHashMap: any2stringadd[ParHashMap[K, V]]).+(other)

Definition Classes

any2stringadd

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