Трейт scala.collection.mutable.IndexedSeqView.Filtered

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

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

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

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

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

Пример:

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

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

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

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

Мемоническое правило для +: vs. :+ такое: двоеточие ставится со стороны коллекции.

Пример:

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

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

Это более обобщённая форма 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" выбран. Однако, поскольку все они идентичны, будет выбран только один. Какой из трех будет выбран — это деталь реализации, которая не определена.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Шаблонный метод, который необходимо переопределить в каждом подклассе. Этот метод можно было бы устранить, если бы в Scala были виртуальные классы

Шаблонный метод, который необходимо переопределить в каждом подклассе. Этот метод можно было бы устранить, если бы в Scala были виртуальные классы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Преобразует эту коллекцию 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.

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

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

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

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

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

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

Zips this mutable indexed sequence with its indices.