Трейт scala.collection.mutable.IndexedSeq

Трейт IndexedSeq[T] extends Seq[T] with IndexedSeq[T] with IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]] with IterableFactoryDefaults[T, IndexedSeq]

Конкретные методы

Исходный код

переопределенный def iterableFactory: SeqFactory[IndexedSeq]

Наследованные методы

Исходный код@inline

финальный def ++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

Псевдоним для concat

Исходный код@inline

финальный переопределенный def ++:[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]

Псевдоним для prependedAll

Исходный код@inline

финальный def +:[B >: T](elem: B): IndexedSeq[B]

Псевдоним для prepended.

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

Исходный код@inline

финальный def :+[B >: T](elem: B): IndexedSeq[B]

Псевдоним для appended.

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

Исходный код@inline

финальный def :++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

Псевдоним для appendedAll

Исходный код@inline

финальный def addString(b: StringBuilder): StringBuilder

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

Исходный код@inline

финальный def addString(b: StringBuilder, sep: String): StringBuilder

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

Исходный код

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

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

Источник

def andThen[C](k: PartialFunction[T, C]): PartialFunction[Int, C]

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

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

Источник

override def andThen[C](k: T => C): PartialFunction[Int, C]

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

Если тип функции в момент выполнения является PartialFunction, используется другой метод andThen (обратите внимание на предостережения).

Источник

def appended[B >: T](elem: B): IndexedSeq[B]

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

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

Пример:

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)

Источник

def appendedAll[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def apply(i: Int): T

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

Источник

def applyOrElse[A1 <: Int, B1 >: T](x: A1, default: A1 => B1): B1

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

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

Источник

def canEqual(that: Any): Boolean

Источник

override def clone(): IndexedSeq[T]

Источник

def collect[B](pf: PartialFunction[T, B]): IndexedSeq[B]

Источник

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

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

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

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

Источник

def combinations(n: Int): Iterator[IndexedSeq[T]]

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

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

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, T]

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

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

Источник@unspecialized

def compose[A](g: A => Int): A => T

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

Источник@inline

final override def concat[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

Источник

def contains[A1 >: T](elem: A1): Boolean

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

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

Источник

def containsSlice[B >: T](that: Seq[B]): Boolean

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

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

Источник

def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: T](xs: Array[B], start: Int): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: T](xs: Array[B]): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (T, B) => Boolean): Boolean

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

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

Исходный код

def corresponds[B](that: Seq[B])(p: (T, B) => Boolean): Boolean

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

Исходный код

def count(p: T => Boolean): Int

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

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

Исходный код

def diff[B >: T](that: Seq[B]): IndexedSeq[T]

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

Исходный код

def distinct: IndexedSeq[T]

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

Исходный код

def distinctBy[B](f: T => B): IndexedSeq[T]

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

Исходный код

override def drop(n: Int): IndexedSeq[T]

Исходный код

override def dropRight(n: Int): IndexedSeq[T]

Источник

def dropWhile(p: T => Boolean): IndexedSeq[T]

Источник

def elementWise: ElementWiseExtractor[Int, T]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Источник

override def empty: IndexedSeq[T]

Источник

def endsWith[B >: T](that: Iterable[B]): Boolean

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

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

Источник

override def equals(o: Any): Boolean

Источник

def exists(p: T => Boolean): Boolean

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

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

Источник

def filter(pred: T => Boolean): IndexedSeq[T]

Source

def filterNot(pred: T => Boolean): IndexedSeq[T]

Source

def find(p: T => Boolean): Option[T]

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

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

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

Source

def findLast(p: T => Boolean): Option[T]

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

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

Source

def flatMap[B](f: T => IterableOnce[B]): IndexedSeq[B]

Source

def flatten[B](implicit asIterable: T => IterableOnce[B]): IndexedSeq[B]

Source

def fold[A1 >: T](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Source

def foldLeft[B](z: B)(op: (B, T) => B): B

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

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

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

Source

override def foldRight[B](z: B)(op: (T, B) => B): B

Source

def forall(p: T => Boolean): Boolean

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

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

Source

def foreach[U](f: T => U): Unit

Применяет f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи в выводе типов scalac.

Source

protected def fromSpecific(coll: IterableOnce[T]): IndexedSeq[T]

Source

def groupBy[K](f: T => K): Map[K, IndexedSeq[T]]

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

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

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Source

def groupMap[K, B](key: T => K)(f: T => B): Map[K, IndexedSeq[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

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

Source

def groupMapReduce[K, B](key: T => K)(f: T => B)(reduce: (B, B) => B): Map[K, B]

Разделяет эту итерируемую коллекцию на карту согласно функции-дискриминатору key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются функцией f и затем сводятся к одному значению функцией reduce.

Это эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

Source

def grouped(size: Int): Iterator[IndexedSeq[T]]

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

Source

override def hashCode(): Int

Source

override def head: T

Source

override def headOption: Option[T]

Source@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B >: T](elem: B): Int

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

Source

def indexOf[B >: T](elem: B, from: Int): Int

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

Source@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

def indexOfSlice[B >: T](that: Seq[B]): Int

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

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

Источник

def indexOfSlice[B >: T](that: Seq[B], from: Int): Int

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

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

Источник@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

def indexWhere(p: T => Boolean): Int

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

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

Источник

def indexWhere(p: T => Boolean, from: Int): Int

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

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

Источник

def indices: Range

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

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставит элементы.

Источник

def init: IndexedSeq[T]

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

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставит элементы.

Source

def inits: Iterator[IndexedSeq[T]]

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

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

Source

def intersect[B >: T](that: Seq[B]): IndexedSeq[T]

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

Source

def isDefinedAt(idx: Int): Boolean

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

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

Source

override def isEmpty: Boolean

Source

override def isTraversableAgain: Boolean

Source

def iterator: Iterator[T]

Source

override def knownSize: Int

Source

override def last: T

Source

def lastIndexOf[B >: T](elem: B, end: Int): Int

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

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

Источник@deprecatedOverriding("Замените lastIndexOfSlice(that, end) вместо этого - lastIndexOfSlice(that) вызывает lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

def lastIndexOfSlice[B >: T](that: Seq[B]): Int

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

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

Источник

def lastIndexOfSlice[B >: T](that: Seq[B], end: Int): Int

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

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

Источник@deprecatedOverriding("Замените lastIndexWhere(p, end) вместо этого - lastIndexWhere(p) вызывает lastIndexWhere(p, Int.MaxValue)", "2.13.0")

def lastIndexWhere(p: T => Boolean): Int

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

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

Источник

def lastIndexWhere(p: T => Boolean, end: Int): Int

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

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

Источник

def lastOption: Option[T]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[T, B, IndexedSeq[T]]

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

Вызовы lazyZip могут быть объединены для поддержки высших арифметических значений (до 4) без затрат на создание и деконструирование промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Источник

def length: Int

Длина (количество элементов) последовательности. size является псевдонимом для length в коллекциях Seq.

Источник

final override def lengthCompare(that: Iterable[_]): Int

Источник

final override def lengthCompare(len: Int): Int

Источник@inline

final def lengthIs: SizeCompareOps

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

Эти операции реализованы с помощью lengthCompare(Int) и позволяют использовать более читабельные выражения:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Источник

def lift: Int => Option[T]

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

Источник

override def map[B](f: T => B): IndexedSeq[B]

Источник

def mapInPlace(f: T => T): IndexedSeq[T]

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

Источник

def max[B >: T](implicit ord: Ordering[B]): T

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

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

Источник

def maxBy[B](f: T => B)(implicit cmp: Ordering[B]): T

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

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

Источник

def maxByOption[B](f: T => B)(implicit cmp: Ordering[B]): Option[T]

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

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

Источник

def maxOption[B >: T](implicit ord: Ordering[B]): Option[T]

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

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

Источник

def min[B >: T](implicit ord: Ordering[B]): T

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

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

Источник

def minBy[B](f: T => B)(implicit cmp: Ordering[B]): T

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

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

Источник

def minByOption[B](f: T => B)(implicit cmp: Ordering[B]): Option[T]

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

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

Источник

def minOption[B >: T](implicit ord: Ordering[B]): Option[T]

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

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

Источник@inline

final def mkString: String

Отображает все элементы этой коллекции в строке.

Делегирует addString, который может быть переопределён.

Источник@inline

final def mkString(sep: String): String

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

Делегирует вызов addString, который может быть переопределён.

Источник

final def mkString(start: String, sep: String, end: String): String

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

Делегирует вызов addString, который может быть переопределён.

Источник

protected def newSpecificBuilder: Builder[T, IndexedSeq[T]]

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Источник

def orElse[A1 <: Int, B1 >: T](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Источник

def padTo[B >: T](len: Int, elem: B): IndexedSeq[B]

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

Source

def partition(p: T => Boolean): (IndexedSeq[T], IndexedSeq[T])

Пара из, во-первых, всех элементов, удовлетворяющих предикату p, и, во-вторых, всех элементов, которые не удовлетворяют ему. Интересно, потому что разделяет коллекцию на две части.

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

Source

def partitionMap[A1, A2](f: T => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])

Применяет функцию f к каждому элементу итерируемой коллекции и возвращает пару итерируемых коллекций: первая содержит те значения, возвращённые функцией f, которые были обернуты в scala.util.Left, а вторая — те, которые были обернуты в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Source

def patch[B >: T](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]

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

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

Source

def permutations: Iterator[IndexedSeq[T]]

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

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

Source

override def prepended[B >: T](elem: B): IndexedSeq[B]

Source

def prependedAll[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]

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

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

Source

def product[B >: T](implicit num: Numeric[B]): B

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

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

Source

def reduce[B >: T](op: (B, B) => B): B

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

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

Source

def reduceLeft[B >: T](op: (B, T) => B): B

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

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

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

Source

def reduceLeftOption[B >: T](op: (B, T) => B): Option[B]

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

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

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

Источник

def reduceOption[B >: T](op: (B, B) => B): Option[B]

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

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

Источник

def reduceRight[B >: T](op: (T, B) => B): B

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

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

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

Источник

def reduceRightOption[B >: T](op: (T, B) => B): Option[B]

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

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

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

Источник

override def reverse: IndexedSeq[T]

Источник

override def reverseIterator: Iterator[T]

Источник

override protected def reversed: Iterable[T]

Источник

def runWith[U](action: T => U): Int => Boolean

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

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

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

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

Источник

def sameElements[B >: T](that: IterableOnce[B]): Boolean

Являются ли элементы этой коллекции такими же (и в том же порядке), как элементы that?

Источник

def scan[B >: T](z: B)(op: (B, B) => B): IndexedSeq[B]

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

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

Источник

def scanLeft[B](z: B)(op: (B, T) => B): IndexedSeq[B]

Источник

def scanRight[B](z: B)(op: (T, B) => B): IndexedSeq[B]

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

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

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

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

Пример:

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

Источник

override def search[B >: T](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

Источник

override def search[B >: T](elem: B)(implicit ord: Ordering[B]): SearchResult

Источник

def segmentLength(p: T => Boolean, from: Int): Int

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

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

Источник

final def segmentLength(p: T => Boolean): Int

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

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

Источник

final override def size: Int

Источник

final override def sizeCompare(that: Iterable[_]): Int

Источник

final override def sizeCompare(otherSize: Int): Int

Источник@inline

final def sizeIs: SizeCompareOps

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

Эти операции реализованы в терминах sizeCompare(Int) и позволяют использовать следующие более удобочитаемые варианты:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Источник

override def slice(from: Int, until: Int): IndexedSeq[T]

Источник

def sliding(size: Int, step: Int): Iterator[IndexedSeq[T]]

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

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

Источник

def sliding(size: Int): Iterator[IndexedSeq[T]]

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

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

Источник

def sortBy[B](f: T => B)(implicit ord: Ordering[B]): IndexedSeq[T]

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Источник

def sortInPlace[B >: T]()(implicit ord: Ordering[B]): IndexedSeq[T]

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

Источник

def sortInPlaceBy[B](f: T => B)(implicit ord: Ordering[B]): IndexedSeq[T]

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

Источник

def sortInPlaceWith(lt: (T, T) => Boolean): IndexedSeq[T]

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

Источник

def sortWith(lt: (T, T) => Boolean): IndexedSeq[T]

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

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

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

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

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Источник

def sorted[B >: T](implicit ord: Ordering[B]): IndexedSeq[T]

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

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

Источник

def span(p: T => Boolean): (IndexedSeq[T], IndexedSeq[T])

Источник

override def splitAt(n: Int): (IndexedSeq[T], IndexedSeq[T])

Источник

def startsWith[B >: T](that: IterableOnce[B], offset: Int): Boolean

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

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

Источник

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S & EfficientSplit

Источник

def sum[B >: T](implicit num: Numeric[B]): B

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

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

Источник

def tail: IndexedSeq[T]

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

Источник

def tails: Iterator[IndexedSeq[T]]

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

Источник

override def take(n: Int): IndexedSeq[T]

Источник

override def takeRight(n: Int): IndexedSeq[T]

Источник

def takeWhile(p: T => Boolean): IndexedSeq[T]

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

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

Источник

override def tapEach[U](f: T => U): IndexedSeq[T]

Источник

def to[C1](factory: Factory[T, C1]): C1

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

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Источник

def toArray[B >: T : ClassTag]: Array[B]

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

Примечание к реализации: НЕ вызывайте Array.from из этого метода.

Источник@inline

final def toBuffer[B >: T]: Buffer[B]

Источник

def toIndexedSeq: IndexedSeq[T]

Источник

def toList: List[T]

Источник

def toMap[K, V](implicit ev: T <:< (K, V)): Map[K, V]

Источник

def toSeq: Seq[T]

Источник

def toSet[B >: T]: Set[B]

Источник

override def toString(): String

Источник

def toVector: Vector[T]

Источник

def transpose[B](implicit asIterable: T => Iterable[B]): IndexedSeq[IndexedSeq[B]]

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

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

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

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

Источник

def unapply(a: Int): Option[T]

Попытка извлечь B из A в выражении сопоставления с образцом.

Источник

def unzip[A1, A2](implicit asPair: T => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])

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

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

Источник

def unzip3[A1, A2, A3](implicit asTriple: T => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])

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

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def update(idx: Int, elem: T): Unit

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

Источник

def updated[B >: T](index: Int, elem: B): IndexedSeq[B]

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

Источник

override def view: IndexedSeqView[T]

Источник

def withFilter(p: T => Boolean): WithFilter[T, IndexedSeq]

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

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

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

Источник

def zip[B](that: IterableOnce[B]): IndexedSeq[(T, B)]

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

Источник

def zipAll[A1 >: T, B](that: Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]

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

Источник

def zipWithIndex: IndexedSeq[(T, Int)]