Класс scala.Array

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

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

A copy of this array with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Example:

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 })

Элемент по заданному индексу.

Индексы начинаются с 0; xs.apply(0) — это первый элемент массива xs. Обратите внимание, что синтаксис индексирования xs(i) — это сокращение для xs.apply(i).

Приведение объекта-получателя к типу 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. Тип 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).

Метод равенства для ссылочных типов. Реализация по умолчанию делегирует eq.

См. также equals в scala.Any.

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

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

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

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

Подробности о том, когда и будет ли вызываться метод 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Разбуждает один поток, ждущий на мониторе объекта-приёмника.

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

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

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

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

Специфические наборы (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельный набор, использующий ту же базовую структуру данных. Для этих наборов 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.) Шаг "скользящего окна" устанавливается в единицу.

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

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

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

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

Сортировка стабильна. То есть элементы, которые равны (как определено 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 элементов.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт строковое представление этого объекта. Представление по умолчанию зависит от платформы. На платформе Java это конкатенация имени класса, "@", и хэш-кода объекта в шестнадцатеричном формате.

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

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

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

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

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

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

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

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

Индексы начинаются с 0; xs.update(i, x) заменяет i-й элемент в массиве. Обратите внимание, что синтаксис xs(i) = x является сокращением для xs.update(i, x).

Копия этого массива с одним заменённым элементом.

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

Создаёт представление этого iterable @see Iterable.View

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

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

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

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

Сцепляет этот массив с его индексами.

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

Пример:

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

scala> x(3)
res1: Int = 4

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

Хеш-коды для Array генерируют значение из хеш-кодов всех элементов изменяемой индексированной последовательности.

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

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

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

Создает строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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