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

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

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

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

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

Добавляет один элемент в билдер.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

По умолчанию этот метод возвращает false.

Очищает содержимое этого билдера. После выполнения этого метода билдер не будет содержать элементов.

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

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

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

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

Объединяет содержимое билдера-получателя и билдера other, создавая новый билдер, содержащий оба их элемента.

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

Обратите внимание, что и билдер-получатель, и билдер other становятся недействительными после вызова этого метода и должны быть очищены (см. clear), если они будут использоваться снова.

Кроме того, объединение двух комбинируемых c1 и c2, для которых c1 eq c2 является true, то есть они являются одними и теми же объектами в памяти:

c1.combine(c2)

всегда ничего не делает и возвращает c1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

и используя элементы полученных коллекций.

Например:

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Эквивалентно !(this eq that).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Строит результат и устанавливает соответствующий объект tasksupport в результирующей коллекции, если это применимо.

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

Размер этого параллельного отображения.

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

Указывает, что ожидается, что размер этого билдера будет таким же, как и у заданной коллекции, плюс некоторое значение delta. Это будет указано только в том случае, если у коллекции есть метод size, который имеет низкую стоимость. В настоящее время это предполагается только в том случае, если коллекция типа IndexedSeqLike. Некоторые классы билдеров оптимизируют свое представление на основе подсказки. Однако реализации билдеров по-прежнему должны работать правильно, даже если подсказка неверна, то есть добавлено другое количество элементов.

Указывает, что ожидается, что размер result этого билдера будет таким же, как и у данного набора, плюс некоторая дельта. Это будет указано только в том случае, если известно, что у набора есть метод size с низкой стоимостью вычисления, что определяется вызовом sizeHint.

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

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

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вот способ изменения поддержки задач параллельной коллекции:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Сцепляет эту параллельную карту с её индексами.

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