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

Объект-компаньон object ParHashMap

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

Параллельная карта-хеш.

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

K: Тип ключей в параллельной карте-хеш
V: Тип значений в параллельной карте-хеш

Тип-объект: ParHashMap[K, V]
Аннотации: @SerialVersionUID()
Источник: ParHashMap.scala

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

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

новый ParHashMap()

Члены типов

тракт 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

абстрактный класс 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

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

Attributes: protected[this]
Definition Classes: ParIterableLike

trait TaskOps[R, Tp] extends AnyRef

Definition Classes: ParIterableLike

class ToParCollection[U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]

Attributes: protected[this]
Definition Classes: ParIterableLike

class ToParMap[K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]

Attributes: protected[this]
Definition Classes: ParIterableLike

trait Transformer[R, Tp] extends Accessor[R, Tp]

Attributes: protected
Definition Classes: ParIterableLike

class Zip[U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]

Attributes: protected[this]
Definition Classes: ParIterableLike

class ZipAll[U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]

Attributes: protected[this]
Definition Classes: ParIterableLike

class DefaultKeySet extends ParSet[K]

Attributes: protected
Definition Classes: ParMapLike

class DefaultValuesIterable extends ParIterable[V]

Attributes: protected
Definition Classes: ParMapLike

type Entry = DefaultEntry[K, V]

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

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

Определение классов: ParIterableLike

абстрактный класс EntryIterator[T, +IterRepr <: IterableSplitter[T]] extends IterableSplitter[T] with SizeMapUtils

Параллельный итератор, возвращающий все записи.

Определение классов: ParHashTable

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

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)): ParMap[K, U]

Определяющие классы: ParMapLike → 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 ++=(xs: TraversableOnce[(K, V)]): ParHashMap.this.type

Добавляет все элементы, полученные из TraversableOnce, в эту коллекцию, допускающую расширение.

xs: TraversableOnce, генерирующая элементы для добавления.
возвращает: собственно коллекция, допускающая расширение.

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

def +=(kv: (K, V)): ParHashMap.this.type

Добавляет один элемент в эту параллельную хеш-таблицу.

возвращает: собственно параллельная хеш-таблица

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

def +=(elem1: (K, V), elem2: (K, V), elems: (K, V)*): ParHashMap.this.type

Добавляет два или более элементов в эту коллекцию, допускающую расширение.

elem1: первый добавляемый элемент.
elem2: второй добавляемый элемент.
elems: остальные добавляемые элементы.
возвращает: собственно коллекцию, допускающую расширение

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

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

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

def --=(xs: TraversableOnce[K]): ParHashMap.this.type

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

xs: итератор, создающий элементы для удаления.
returns: сам изменяемый по размеру набор

Definition Classes: Shrinkable

def -=(key: K): ParHashMap.this.type

Удаляет один элемент из этого параллельного хеш-карты.

returns: сам параллельный хеш-массив

Definition Classes: ParHashMap → ParMapLike → Shrinkable

def -=(elem1: K, elem2: K, elems: K*): ParHashMap.this.type

Удаляет два или более элементов из этого изменяемого по размеру набора.

elem1: первый элемент для удаления.
elem2: второй элемент для удаления.
elems: остальные элементы для удаления.
returns: сам изменяемый по размеру набор

Definition Classes: Shrinkable

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

Implicit: Этот член добавлен неявным преобразованием из ParHashMap[K, V] в ArrowAssoc[ParHashMap[K, V]] с помощью метода ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @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

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

returns

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

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

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

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

Примеры:

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

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

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

z

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

op

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

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

val _loadFactor: Int

Attributes: protected
Definition Classes: HashTable
Annotations: @transient()

def addEntry(e: DefaultEntry[K, V]): Unit

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

Атрибуты: protected
Определяющие классы: HashTable
Аннотации: @deprecatedOverriding( сообщение = ... , начиная с = "2.11.0" )

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(_), _ ++ _)

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

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

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

def alwaysInitSizeMap: Boolean

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

def apply(key: K): V

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

final def asInstanceOf[T0]: T0

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

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

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

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

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

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

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

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

def calcSizeMapSize(tableLength: Int): Int

Атрибуты: protected
Определяющие классы: HashTable
Аннотации: @deprecatedOverriding( сообщение = ... , начиная с = "2.11.0" )

def canEqual(other: Any): Boolean

Definition Classes: ParIterableLike

def clear(): Unit

Очищает содержимое параллельной хэш-таблицы. После этой операции параллельная хэш-таблица пуста.

Definition Classes: ParHashMap → ParMapLike → Growable → Clearable

def clearTable(): Unit

Удаляет все записи из таблицы

Attributes: protected
Definition Classes: HashTable

def clone(): ParHashMap[K, V]

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

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

returns: копия объекта-получателя.

Definition Classes: Cloneable → AnyRef
Note: не определено SLS как член AnyRef

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

[use case]

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

для которых функция определена.

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

Definition Classes: ParIterableLike → GenTraversableLike

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

Attributes: protected[this]
Definition Classes: ParIterableLike

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

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

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

Attributes: protected[this]
Definition Classes: ParIterableLike

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

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

Definition Classes: ParIterable → ParIterable → GenericParTemplate → GenIterable → GenTraversable → GenericTraversableTemplate

def contains(key: K): Boolean

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

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

Definition Classes: ParMapLike → GenMapLike

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

[use case]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def count(p: ((K, V)) ⇒ Boolean): Int

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def createNewEntry[V1](key: K, value: V1): Entry

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

Attributes: protected
Definition Classes: ParHashMap → HashTable

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 elemEquals(key1: K, key2: K): Boolean

Attributes: protected
Definition Classes: HashTable

def elemHashCode(key: K): Int

Attributes: protected
Definition Classes: HashUtils

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

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

Неявный: ...
Definition Classes: ...

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

Неявный: ...
Definition Classes: ...

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

Неявный: ...
Definition Classes: ...

def entriesIterator: Iterator[DefaultEntry[K, V]]

Итератор, возвращающий все записи.

Attributes: protected
Definition Classes: HashTable

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

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

Definition Classes: AnyRef

def equals(that: Any): Boolean

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

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

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

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def findEntry(key: K): DefaultEntry[K, V]

Находит запись с заданным ключом в таблице, null, если не найдена.

Attributes: protected
Definition Classes: HashTable
Annotations: @deprecatedOverriding( message = ... , since = "2.11.0" )

def findOrAddEntry[B](key: K, value: B): DefaultEntry[K, V]

Находит запись с заданным ключом в таблице или добавляет новую, если не найдена. Может быть несколько быстрее, чем пара findEntry/addEntry, так как вычисляет индекс хеширования записи только один раз. Возвращает запись, найденную в таблице, или null. Новые записи создаются вызовом метода createNewEntry.

Attributes: protected
Definition Classes: HashTable

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]

[use case]

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

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

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

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

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

Definition Classes: GenericTraversableTemplate

def fold[U >: (K, V)](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, (K, V)) ⇒ S): S

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

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

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

z

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

op

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

возвращает

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

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

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

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

def foldRight[S](z: S)(op: ((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

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

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

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

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

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

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

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

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

Избегайте итератора для 2-кратного ускорения обхода.

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

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

Definition Classes: GenericParMapTemplate

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

Definition Classes: ParHashMap → GenMapLike

final def getClass(): Class[_]

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

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

Definition Classes: AnyRef → Any
Annotations: @native()

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

[use case]

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

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

Definition Classes: ParMapLike → GenMapLike

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

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

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

K

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

f

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

returns

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def hasDefiniteSize: Boolean

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def hashCode(): Int

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

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

Definition Classes: GenMapLike → AnyRef → Any

def head: (K, V)

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

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

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

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

def headOption: Option[(K, V)]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

final def improve(hcode: Int, seed: Int): Int

Обращение к высококачественному хэшу в scala.util.hashing. Цель — распределение по корзинам наилучшим образом, даже если код хэша имеет низкую энтропию по некоторым битам.

СТАРАЯ ВЕРСИЯ — быстрая, но плохая для последовательностей 0-10000 — малая энтропия в старших битах — с 2003 года

var h: Int = hcode + ~(hcode << 9)
h = h ^ (h >>> 14)
h = h + (h << 4)
h ^ (h >>> 10)

остальная часть вычислений связана с scala/bug#5293

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

final def index(hcode: Int): Int

Примечание: мы используем наиболее значимые биты хэш-кода, а не младшие. Это имеет решающее значение при параллельном заполнении таблицы

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

def init: ParHashMap[K, V]

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

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

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

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

def initTaskSupport(): Unit

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

def initWithContents(c: Contents[K, DefaultEntry[K, V]]): Unit

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

def initialSize: Int

Начальный размер хеш-таблицы.

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

def isDefinedAt(key: K): Boolean

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

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

Классы определений: ParMapLike → GenMapLike

def isEmpty: Boolean

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

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

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

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

def isSizeMapDefined: Boolean

Атрибуты: protected
Классы определений: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def isStrictSplitterCollection: Boolean

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

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

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

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

final def isTraversableAgain: Boolean

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

возвращает: true

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

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

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

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

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

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

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

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

Атрибуты: protected[this]
Классы определений: ParHashMap → ParMap → GenericParMapTemplate → GenericParTemplate → HasNewCombiner

def nnSizeMapAdd(h: Int): Unit

Атрибуты: protected
Классы определений: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def nnSizeMapRemove(h: Int): Unit

Атрибуты: protected
Классы определений: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def nnSizeMapReset(tableLength: Int): Unit

Атрибуты: protected
Классы определений: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def nonEmpty: Boolean

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

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

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

final def notify(): Unit

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

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

final def notifyAll(): Unit

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

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

def par: ParHashMap[K, V]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def product: A

[use case]

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def put(key: K, value: V): Option[V]

Definition Classes: ParHashMap → ParMapLike

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: Значение Option, содержащее результат применения оператора 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
Исключения: UnsupportedOperationException, если этот параллельный итерируемый объект пуст.

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def remove(key: K): Option[V]

def removeEntry(key: K): DefaultEntry[K, V]

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

Attributes: protected
Definition Classes: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

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

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

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

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

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

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

def scanBlockSize: Int

Атрибуты: protected[this]
Классы-определения: 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.
возвращает: коллекция с промежуточными результатами

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

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

val seedvalue: Int

Атрибуты: protected
Классы-определения: HashTable
Аннотации: @transient()

def seq: HashMap[K, V]

Классы-определения: ParHashMap → ParMap → ParIterable → ParIterableLike → GenMap → GenIterable → GenTraversable → GenMapLike → Parallelizable → GenTraversableOnce

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

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

def size: Int

Размер этой параллельной хеш-таблицы.

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

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

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

def sizeHintIfCheap: Int

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

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

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

final def sizeMapBucketBitSize: Int

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

final def sizeMapBucketSize: Int

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

def sizeMapDisable(): Unit

Атрибуты: protected
Классы-определения: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def sizeMapInit(tableLength: Int): Unit

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

def sizeMapInitAndRebuild(): Unit

Атрибуты: protected
Классы-определения: HashTable
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

val sizemap: Array[Int]

Массив, отслеживающий количество элементов в блоках по 32 элемента.

Атрибуты: protected
Классы-определения: HashTable
Аннотации: @transient()

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

Классы-определения: 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: ParHashMapIterator

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

returns: параллельный итератор

Definition Classes: ParHashMap → ParIterableLike

def stringPrefix: String

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

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

Definition Classes: ParHashMap → ParMap → ParIterable → GenTraversableLike

def sum: A

[use case]

Суммирует элементы этой коллекции.

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

Definition Classes: ParIterableLike → GenTraversableOnce

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

Definition Classes: AnyRef

val table: Array[HashEntry[K, DefaultEntry[K, V]]]

Фактическая хеш-таблица.

Attributes: protected
Definition Classes: HashTable
Annotations: @transient()

val tableSize: Int

Количество сопоставлений, содержащихся в этой хеш-таблице.

Attributes: protected
Definition Classes: HashTable
Annotations: @transient()

def tableSizeSeed: Int

Attributes: protected
Definition Classes: HashTable

def tail: ParHashMap[K, V]

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

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

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

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

явное определение task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]

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

определение tasksupport: TaskSupport

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

Определяющие классы: ParIterableLike
См. также: scala.collection.parallel.TaskSupport

определение 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))

Определяющие классы: ParIterableLike
См. также: scala.collection.parallel.TaskSupport

значение threshold: Int

Следующее значение размера, при котором происходит изменение размера (ёмкость * коэффициент заполнения).

Атрибуты: protected
Определяющие классы: HashTable
Аннотации: @transient()

определение to[Col[_]]: Col[A]

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

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

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

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

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

определение toArray: Array[A]

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

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

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

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

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

определение toBuffer[U >: (K, V)]: Buffer[U]

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

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

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

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

определение toIndexedSeq: immutable.IndexedSeq[(K, V)]

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

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

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

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

определение toIterable: ParIterable[(K, V)]

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

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

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

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

определение toIterator: scala.Iterator[(K, V)]

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

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

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

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

def toList: Список[(K, V)]

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

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

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

Определения классов: ParIterableLike → GenTraversableOnce

def toMap[T, U]: Карта[T, U]

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

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

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

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

Определения классов: ParIterableLike → GenTraversableOnce

def toParArray: ParArray[T]

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

def toParCollection[U >: (K, V), That](cbf: () ⇒ Комбинатор[U, That]): That

Атрибуты: protected
Определения классов: ParIterableLike

def toParMap[K, V, That](cbf: () ⇒ Комбинатор[(K, V), That])(implicit ev: <:<[(K, V), (K, V)]): That

Атрибуты: protected
Определения классов: ParIterableLike

def toSeq: ParSeq[(K, V)]

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

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

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

Определения классов: ParIterable → ParIterableLike → GenTraversableOnce

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

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

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

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

Определения классов: ParIterableLike → GenTraversableOnce

def toStream: Поток[(K, V)]

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

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

Определения классов: ParIterableLike → GenTraversableOnce

def toString(): Строка

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

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

Definition Classes: ParIterableLike → AnyRef → Any

def toTraversable: GenTraversable[(K, V)]

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

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def toVector: Vector[(K, V)]

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

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

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

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

Definition Classes: GenericTraversableTemplate
Annotations: @migration
Migration: (Изменено в версии 2.9.0) transpose вызывает IllegalArgumentException если размеры коллекций не одинаковы.
Exceptions thrown: 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: неявное преобразование, утверждающее, что тип элемента этой коллекции — пара.
returns: пара коллекций, содержащая первую и, соответственно, вторую половину каждой пары элементов этой коллекции.

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

Definition Classes: GenericTraversableTemplate

def update(key: K, value: V): Unit

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

Definition Classes: ParMap → ParMap → GenMap

def values: parallel.ParIterable[V]

Собирает все значения этого отображения в итерабельную коллекцию.

returns: значения этого отображения в виде итерабельного объекта.

Definition Classes: ParMapLike → GenMapLike

def valuesIterator: IterableSplitter[V]

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

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

Definition Classes: ParMapLike → GenMapLike

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

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

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

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

Definition Classes: ParMap

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

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

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

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

Definition Classes: ParMap

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

Definition Classes: ParIterableLike

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

Attributes: protected
Definition Classes: ParIterableLike

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

[use case]

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

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

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

Definition Classes: 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/mutable/ParHashMap.html