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

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

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

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

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

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

Пример:

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

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

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

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

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

Пример:

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 являются бесконечными последовательностями, этот метод может не завершиться.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает итератор по элементам в этой итерируемой коллекции. Производит тот же результат, что и iterator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Представление подпоследовательности, начинающейся с индекса from и продолжающейся до (но не включая) индекса until.

Создаёт представление этого итерируемого объекта @см Iterable.View

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

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

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

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

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

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