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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итерируется по начальным подпоследовательностям (inits) этой коллекции перебираемых объектов. Первое значение будет этой коллекцией перебираемых объектов, а последнее — пустой коллекцией перебираемых объектов, а промежуточные значения — результатами последовательного применения 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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