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

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

Эквивалентно 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]] — нет. В последнем примере, поскольку тип аргумента стирается во время компиляции, нельзя проверить, соответствуют ли содержимое списка требуемому типу.

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

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

По умолчанию реализация метода 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)

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

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

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.

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

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

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

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

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

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

Необязательно использует существующий комбинирующий объект для повышения производительности. По умолчанию не использует — подклассы могут переопределить это поведение. Предоставленный комбинирующий объект 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, и дополнена дополнительными методами доступа и преобразования.

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

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

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

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

Выбирает первые 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))

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

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

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

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

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

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

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

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

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

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

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