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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поворачивает двумерный массив.

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

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