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

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

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

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

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

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

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

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

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

Клонирует этот объект, включая базовый массив.

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

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

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

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

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

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

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

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

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

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

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

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

Копирует элементы этого обернутого массива в массив. Заполняет заданный массив 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.

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

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

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

Проверяет, является ли аргумент (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 может гарантировать, что размер определён и не возникает проблем с завершением.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Длина массива

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Сортирует эту последовательность в соответствии с 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 элементов.

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

Базовая коллекция, рассматриваемая как экземпляр 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))

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

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

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

Создаёт представление этого итерируемого объекта. @см Iterable.View

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

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

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

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

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

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