Класс scala.collection.mutable.ArrayOps.ofBoolean

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

Эквивалентно 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)

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

Обратите внимание, что операторы с окончанием «:-» являются правоассоциативными (см. пример). Мнемоника для +: vs. :+ такова: двоеточие ставится со стороны коллекции.

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

Пример:

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

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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

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

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

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

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

Мнемоника для +: vs. :+ такова: двоеточие ставится со стороны коллекции.

Пример:

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

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

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

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

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

Пример:

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

scala> x(3)
res1: Int = 4

Преобразует объект-получатель к типу T0.

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

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

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

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

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

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

Итерация по комбинациям. _Комбинация_ длины n - это подпоследовательность исходной последовательности, элементы которой взяты в порядке. Таким образом, "xy" и "yy" являются комбинациями длины 2 для "xyy", но "yx" нет. Если существует более одного способа генерации одной и той же подпоследовательности, будет возвращен только один.

Например, "xyyy" имеет три разных способа сгенерировать "xy" в зависимости от того, какой первый, второй или третий "y" выбран. Однако, так как все они идентичны, будет выбран только один. Какой из трех будет выбран, является деталью реализации, которая не определена.

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

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

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

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

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

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

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

Копирует все элементы этой последовательности или итератора в буфер.

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

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

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

Создаёт возможную вложенную IndexedSeq которая состоит из всех элементов этого массива. Если сами элементы являются массивами, то трансформация deep применяется рекурсивно к ним. stringPrefix IndexedSeq является "Массив", поэтому IndexedSeq выводится как массив со всеми его элементами, а также аналогично для любых подмассивов.

Пример:

Array(Array(1, 2), Array(3, 4)).deep.toString

выводит: Array(Array(1, 2), Array(3, 4))

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

Создаёт новую последовательность из этой последовательности без дублирующих элементов.

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

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

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

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

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

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

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

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

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

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

Например:

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)

Разворачивает двумерный массив, конкатенируя все его строки в один массив.

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

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

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

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

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

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

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

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

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

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

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

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

Разделяет элементы на итерируемые коллекции фиксированного размера.

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

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

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

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

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

Находит индекс первого вхождения некоторого значения в этой изменяемой индексированной последовательности после или на определенном начальном индексе.

Находит индекс первого вхождения некоторого значения в этой изменяемой индексированной последовательности.

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

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

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

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

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

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

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

Создает диапазон всех индексов этой последовательности.

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

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

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

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

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

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

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

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

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

Создаёт новый итератор по всем элементам, содержащимся в этом итерируемом объекте.

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

Находит индекс последнего вхождения некоторого значения в этой изменяемой индексированной последовательности перед или в заданном индексе конца.

Находит индекс последнего вхождения некоторого значения в этой изменяемой индексированной последовательности.

Находит последний индекс перед или в заданном индексе конца, где эта последовательность содержит заданную последовательность как срез.

Находит последний индекс, где эта последовательность содержит заданную последовательность как срез.

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

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

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

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

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

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

Длина изменяемой индексированной последовательности.

Примечание: xs.length и xs.size дают одинаковый результат.

Сравнивает длину этой последовательности со значением теста.

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

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

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

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

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

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

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

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

Создаёт новый билдер для этого типа коллекции.

Проверяет, пуст ли обходчик или итератор.

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

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

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

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

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

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

Разделяет эту коллекцию на две части по условию.

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

Итерирует по различным перестановкам.

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

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

Перемножает элементы этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итератор, возвращающий элементы в обратном порядке.

Примечание: xs.reverseIterator эквивалентно xs.reverse.iterator, но может быть более эффективным.

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

Примечание: xs.reverseMap(f) эквивалентно xs.reverse.map(f), но может быть более эффективным.

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

from <= indexOf(x) < until

Группирует элементы в блоки фиксированного размера, перемещая "скользящее окно" по ним (в отличие от разделения на части, как это делается в grouped.)

Группирует элементы в блоки фиксированного размера, перемещая "скользящее окно" по ним (в отличие от разделения на части, как это делается в grouped.) Шаг "скользящего окна" установлен в один.

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

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

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

Сортировка стабильна. То есть, элементы, которые равны (как определено lt ) появляются в отсортированной последовательности в том же порядке, что и в исходной.

Сортирует эту последовательность в соответствии с упорядочением.

Сортировка стабильна. То есть элементы, которые равны (как определено lt ), появляются в отсортированной последовательности в том же порядке, что и в исходной.

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

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

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

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

Примечание: Если оба объекта-получателя this и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

Проверяет, начинается ли эта общая последовательность с заданной последовательности.

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

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

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

Итерируется по хвостам этого набора.

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

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

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

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

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

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

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

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

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

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

Возвращает эту итерируемую коллекцию как итерируемую коллекцию.

Новая коллекция не будет создана; ленивые коллекции останутся ленивыми.

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

Возвращает итератор по элементам этого итерируемого набора. Возвращает тот же результат, что и iterator.

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

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

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

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

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

Новая коллекция не будет построена; в частности, ленивые последовательности останутся ленивыми.

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

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

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

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

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

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

Преобразует этот обходной объект или итератор в вектор.

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

Транспонирует двумерный массив.

Создаёт новую последовательность, содержащую все элементы этой изменяемой индексированной последовательности, а также все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это: xs union ys вычисляет сохраняющую порядок множественную объединение xs и ys. union является поэтому аналогом diff и intersect, которые также работают с множествами.

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

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

Заменяет элемент в заданном индексе новым значением.

A copy of this mutable indexed sequence with one single replaced element.

A sub-sequence view starting at index from and extending up to (but not including) index until.

Creates a view of this iterable @see Iterable.View

Creates a non-strict filter of this traversable collection.

Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Returns a mutable indexed sequence formed from this mutable indexed sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

Returns a mutable indexed sequence formed from this mutable indexed sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.

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