Трейт scala.collection.TraversableProxy

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

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

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

Аналогично ++, возвращает новую коллекцию, содержащую элементы из левого операнда, после которых следуют элементы из правого операнда.

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

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

Аналогично ++, возвращает новую коллекцию, содержащую элементы из левого операнда, после которых следуют элементы из правого операнда.

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

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

Добавляет все элементы этой коллекции перебираемых элементов в строковый буфер. Записываемый текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции перебираемых элементов без разделительной строки.

Пример:

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

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Добавляет все элементы этой коллекции перебираемых элементов в строковый буфер с использованием разделительной строки. Записываемый текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции перебираемых элементов, разделенных строкой sep.

Пример:

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

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Добавляет все элементы этого итерируемого набора в строковый буфер, используя начальную, конечную и разделительные строки. Текст, который будет записан, начинается со строки start и заканчивается строкой end. Внутри строковые представления (относительно метода toString) всех элементов этого итерируемого набора разделяются строкой sep.

Пример:

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

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

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

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

aggregate разбивает итерируемый набор или итератор на разделы и обрабатывает каждый раздел последовательным применением seqop, начиная с z (как foldLeft). Затем эти промежуточные результаты объединяются с помощью combop (как fold). Реализация этой операции может работать с произвольным количеством разделов коллекции (даже 1), поэтому combop может вызываться произвольное количество раз (даже 0).

Например, рассмотрим суммирование целочисленных значений списка символов. Начальное значение суммы равно 0. Во-первых, seqop преобразует каждый входной символ в целое число и добавляет его к сумме (раздела). Затем combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Копирует все элементы этой коллекции-переборщика в буфер.

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

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

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

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

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

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

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

Сравнивает получаемый объект (this) с объектом-аргументом (that) на эквивалентность.

Любая реализация этого метода должна быть отношением эквивалентности:

Она является рефлексивной: для любого экземпляра x типа Any, x.equals(x) должно возвращать true.Она является симметричной: для любых экземпляров x и y типа Any, x.equals(y) должно возвращать true тогда и только тогда, когда y.equals(x) возвращает true.Она является транзитивной: для любых экземпляров x, y и z типа Any, если x.equals(y) возвращает true и y.equals(z) возвращает true, то x.equals(z) должно возвращать true.

При переопределении этого метода необходимо убедиться, что ваша реализация остается отношением эквивалентности. Кроме того, при переопределении этого метода обычно необходимо переопределить hashCode, чтобы гарантировать, что объекты, которые "равны" (o1.equals(o2) возвращает true), хэшируются к одному значению scala.Int. (o1.hashCode.equals(o2.hashCode)).

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

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

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

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

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

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

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

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

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

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

Например:

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Разделяет эту коллекцию traversable на карту коллекций traversable в соответствии с функцией-дискриминатором.

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

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

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

Вычисляет значение хэш-кода для объекта.

Алгоритм хэширования по умолчанию зависит от платформы.

Следует учитывать, что для двух объектов могут быть идентичны хэш-коды (o1.hashCode.equals(o2.hashCode)), но они могут не быть равны (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true), то у них должны быть идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому, при переопределении этого метода, необходимо убедиться, что поведение согласуется с методом equals.

Выбирает первый элемент этой коллекции traversable.

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

Возвращает опционально первый элемент.

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

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

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

Итерирует по начальным частям (inits) этой коллекции traversable. Первое значение будет этой коллекцией traversable, а последнее — пустой коллекцией traversable, а промежуточные значения — результаты последовательных применений init.

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

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

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

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

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

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

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

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

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

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

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

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

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

Отображает все элементы этой коллекции в строку.

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

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

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

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

Проверяет, не пуста ли коллекция.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возможно применяет бинарную операцию ко всем элементам этого набора итерируемых элементов слева направо.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

Этот метод возвращает ссылку на эту коллекцию. В параллельных коллекциях он переопределён для возвращения последовательной реализации этой коллекции. В обоих случаях сложность — O(1).

Размер этой коллекций перебираемых элементов.

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

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

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

from <= indexOf(x) < until

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

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

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не приводит к побочным эффектам.

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

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

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

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

Вычисляет сумму элементов этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Стандартное представление зависит от платформы.

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

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

Преобразует это итерируемое или итератор в вектор.

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

Транспонирует это множество итерируемых множеств в множество множеств.

Тип результирующего множества будет определён статическим типом множества. Например:

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

Создает нестрогую просмотр фрагмента этого коллекционного объекта.

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

Примечание: view(from, to) эквивалентно view.slice(from, to)

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

Создает нестрогую просмотр этого коллекционного объекта.

Создает нестрогую фильтрацию этого коллекционного объекта.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создает новый коллекционный объект, а второй только ограничивает область действия последующих map, flatMap, foreach и withFilter операций.

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