Класс scala.collection.mutable.ArraySeq

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

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

A copy of the array sequence with an element prepended.

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Also, the original array sequence is not modified, so you will want to capture the result.

Example:

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)

Applies a binary operator to a start value and all elements of this traversable or iterator, going left to right.

Note: /: is alternate syntax for foldLeft; z /: xs is the same as xs foldLeft z.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

A copy of this array sequence 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)

Applies a binary operator to all elements of this traversable or iterator and a start value, going right to left.

Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

Appends all elements of this traversable or iterator to a string builder. The written text consists of the string representations (w.r.t. the method toString) of all elements of this traversable or iterator without any separator string.

Example:

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

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

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

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

Создаёт копию текущего объекта.

По умолчанию, реализация метода clone зависит от платформы.

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

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

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

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

Итерируется по комбинациям. _Комбинация_ длины n — это подпоследовательность исходной последовательности, элементы которой взяты в порядке. Таким образом, "xy" и "yy" — это комбинации длины 2 последовательности "xyy", но "yx" не является таковой. Если существует более одного способа генерации одной и той же подпоследовательности, будет возвращена только одна.

Например, "xyyy" имеет три разных способа генерации "xy" в зависимости от того, какой элемент — первый, второй или третий "y" — выбирается. Однако, так как все они идентичны, будет выбран только один. Какой из трёх будет выбран, является деталью реализации, которая не определена.

Объект-компаньон-фабрика, который создает экземпляры класса ArraySeq. (или его Iterable суперкласс, где класс ArraySeq не является Seq.)

Компонует два экземпляра Function1 в новый Function1, при этом эта функция применяется последней.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Выбирает все элементы, кроме первых 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)

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

Разделяет коллекцию на группы по значению функции-дискриминатора.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Длина массива последовательности.

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

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

Преобразует эту частичную функцию в обычную функцию, возвращающую результат Option.

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

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

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

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

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

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

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

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

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

Построитель, создающий экземпляры типа Traversable[A]

Проверяет, не пуст ли обходчик или итератор.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итератор, возвращающий элементы в обратном порядке.

Примечание: xs.reverseIterator то же самое, что и xs.reverse.iterator, но может быть эффективнее.

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

Примечание: xs.reverseMap(f) то же самое, что и xs.reverse.map(f), но может быть эффективнее.

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

Обратите внимание, что выражение 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.)

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

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

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

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

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

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

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

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

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

Разделяет эту последовательность на две части по заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Примечание: Если как объект-получатель this так и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт представление этой последовательности @см. Iterable.View

Создаёт нестрогий фильтр этой коллекцией обхода.

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

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

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

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

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