Класс scala.collection.mutable.WrappedArray.ofRef

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

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

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

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

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

Пример:

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

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

Пример:

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

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

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

Пример:

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 преобразует каждый входной символ в Int и добавляет его к сумме (раздела). Затем combop просто нужно суммировать промежуточные результаты разделов:

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

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

Элемент с заданным индексом

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

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

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

соединение частичных функций в цепочки orElse/andThen не приводит к чрезмерному вычислению apply/isDefinedAt lift и unlift не вычисляют исходные функции дважды при каждом вызове runWith позволяет эффективно комбинировать частичные функции в стиле императивного программирования с применением действий при определенных условиях

Для нелитеральных классов частичных функций с нетривиальным методом isDefinedAt рекомендуется переопределить метод applyOrElse с пользовательской реализацией, которая избегает двойного вычисления isDefinedAt. Это может привести к лучшей производительности и более предсказуемому поведению относительно побочных эффектов.

Базовый массив

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

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

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

Создаёт копию этого объекта, включая базовый массив.

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

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

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

Копирует все элементы этого перечислимого объекта или итератора в буфер.

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

Тег типа элемента

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

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

Метод eq реализует отношение эквивалентности на не-нулевых экземплярах AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых не-нулевых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого не-нулевого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить, чтобы их поведение соответствовало равенству ссылок. Таким образом, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны иметь одинаковое хеш-значение (o1.hashCode == o2.hashCode).

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

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

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

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

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

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

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

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

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Отображает все элементы этого перечислимого или итератора в строке.

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

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

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

Создаёт новый билдер для этой коллекции ==> переместить в подклассы

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

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

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

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

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

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

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

Специфические коллекции (например, `Array` или `ListBuffer`) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая разделяет то же самое основное множество данных. Для этих коллекций метод `par` занимает постоянное или сублинейное время.

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

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Транспонирует эту коллекцию коллекций-объектов-проходимцев в коллекцию коллекций.

Тип результирующей коллекции будет определяться статическим типом коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

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

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

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

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

val xs = Traversable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three),
//        Traversable(1, 2, 3))

Обновить элемент по заданному индексу

A copy of this wrapped array 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 wrapped array formed from this wrapped array 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.

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

Объединяет этот упакованный массив с его индексами.