Класс scala.collection.parallel.ParMap.WithDefault

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вычисляет произведение элементов этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Выбирает интервал элементов. Возвращаемый набор состоит из всех элементов 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))

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

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

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

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

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

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

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

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