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

трейт Seq[A] extends Iterable[A] with Seq[A] with SeqOps[A, Seq, Seq[A]] with IterableFactoryDefaults[A, Seq]

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

Исходный код

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

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

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

final def ++[B >: A](suffix: IterableOnce[B]): Seq[B]

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

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

final override def ++:[B >: A](prefix: IterableOnce[B]): Seq[B]

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

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

final def +:[B >: A](elem: B): Seq[B]

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

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

final def :+[B >: A](elem: B): Seq[B]

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

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

final def :++[B >: A](suffix: IterableOnce[B]): Seq[B]

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

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

final 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

final 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[A, C]): PartialFunction[Int, C]

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

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

Источник

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

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

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

Источник

def appended[B >: A](elem: B): Seq[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 >: A](suffix: IterableOnce[B]): Seq[B]

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

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

def apply(i: Int): A

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

Источник

def applyOrElse[A1 <: Int, B1 >: A](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(): Seq[A]

Источник

def collect[B](pf: PartialFunction[A, B]): Seq[B]

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[Seq[A]]

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

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

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

Исходный код

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

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

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

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

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

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

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

final override def concat[B >: A](suffix: IterableOnce[B]): Seq[B]

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def copyToArray[B >: A](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 >: A](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 >: A](xs: Array[B]): Int

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

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

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

Исходный код

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

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

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

Источник

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

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

Источник

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

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

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

Источник

def diff[B >: A](that: Seq[B]): Seq[A]

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

Источник

def distinct: Seq[A]

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

Источник

def distinctBy[B](f: A => B): Seq[A]

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

Источник

def drop(n: Int): Seq[A]

Источник

def dropRight(n: Int): Seq[A]

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

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

Источник

def dropWhile(p: A => Boolean): Seq[A]

Источник

def elementWise: ElementWiseExtractor[Int, A]

Возвращает объект-экстрактор с методом 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: Seq[A]

Источник

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

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

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

Источник

override def equals(o: Any): Boolean

Источник

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

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

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

Источник

def filter(pred: A => Boolean): Seq[A]

Source

def filterNot(pred: A => Boolean): Seq[A]

Source

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

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

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

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

Source

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

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

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

Source

def flatMap[B](f: A => IterableOnce[B]): Seq[B]

Source

def flatten[B](implicit asIterable: A => IterableOnce[B]): Seq[B]

Source

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

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

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

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

Source

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

protected def fromSpecific(coll: IterableOnce[A]): Seq[A]

Источник

def groupBy[K](f: A => K): Map[K, Seq[A]]

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

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

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

Источник

def groupMap[K, B](key: A => K)(f: A => B): Map[K, Seq[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)

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

Источник

def groupMapReduce[K, B](key: A => K)(f: A => 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)(_ + _)

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

Источник

def grouped(size: Int): Iterator[Seq[A]]

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

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

override def hashCode(): Int

Источник

def head: A

Выбирает первый элемент этой итерируемой коллекции.

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

Источник

def headOption: Option[A]

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

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

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

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

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

Источник

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Исходный код

def init: Seq[A]

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

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

Исходный код

def inits: Iterator[Seq[A]]

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

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

Исходный код

def intersect[B >: A](that: Seq[B]): Seq[A]

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

Исходный код

def isDefinedAt(idx: Int): Boolean

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

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

Исходный код

override def isEmpty: Boolean

Исходный код

override def isTraversableAgain: Boolean

Исходный код

def iterator: Iterator[A]

Итератор может быть использован только один раз

Исходный код

def knownSize: Int

Исходный код

def last: A

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

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

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Источник

def lastOption: Option[A]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Seq[A]]

Аналогично 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 коллекциях.

Источник

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

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

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Источник

def lengthCompare(len: Int): Int

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

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Источник@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[A]

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

Источник

def map[B](f: A => B): Seq[B]

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@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[A, Seq[A]]

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

def nonEmpty: Boolean

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

Источник

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

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

Источник

def padTo[B >: A](len: Int, elem: B): Seq[B]

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

Источник

def partition(p: A => Boolean): (Seq[A], Seq[A])

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

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

Источник

def partitionMap[A1, A2](f: A => Either[A1, A2]): (Seq[A1], Seq[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))

Источник

def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int): Seq[B]

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

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

Источник

def permutations: Iterator[Seq[A]]

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

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

Источник

def prepended[B >: A](elem: B): Seq[B]

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

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

Пример:

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)

Источник

def prependedAll[B >: A](prefix: IterableOnce[B]): Seq[B]

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def reverse: Seq[A]

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

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

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

Источник

def reverseIterator: Iterator[A]

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

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

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

Источник

def scan[B >: A](z: B)(op: (B, B) => B): Seq[B]

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

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

Источник

def scanLeft[B](z: B)(op: (B, A) => B): Seq[B]

Источник

def scanRight[B](z: B)(op: (A, B) => B): Seq[B]

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

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

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

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

Пример:

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

Исходный код

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

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

Перед вызовом набор должен быть отсортирован с использованием того же Ordering ; в противном случае результаты будут неопределенными.

Исходный код

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

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

Перед вызовом набор должен быть отсортирован с использованием того же Ordering ; в противном случае результаты будут неопределенными.

Исходный код

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

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

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

Исходный код

final def segmentLength(p: A => 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

Исходный код

def slice(from: Int, until: Int): Seq[A]

Исходный код

def sliding(size: Int, step: Int): Iterator[Seq[A]]

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

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

Исходный код

def sliding(size: Int): Iterator[Seq[A]]

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

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

Исходный код

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Seq[A]

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

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

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

Сортировка устойчива. То есть, элементы, которые равны (как определено 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 sortWith(lt: (A, A) => Boolean): Seq[A]

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

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

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

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

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

Исходный код

def sorted[B >: A](implicit ord: Ordering[B]): Seq[A]

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

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

Исходный код

def span(p: A => Boolean): (Seq[A], Seq[A])

Исходный код

override def splitAt(n: Int): (Seq[A], Seq[A])

Исходный код

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

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

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

Исходный код

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S

Возвращает scala.collection.Stepper для элементов этой коллекции.

Stepper позволяет создать Java поток для работы с коллекцией, см. scala.jdk.StreamConverters. Для коллекций, содержащих примитивные значения, Stepper можно использовать как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип результирующего Stepper в соответствии с типом элемента этой коллекции.

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

• Для любого другого типа элемента возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределяется в подклассах, и тип возвращаемого значения уточняется до S with EfficientSplit, например scala.collection.IndexedSeqOps.stepper. Для Steppers, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Steppers могут быть преобразованы только в последовательные потоки.

Исходный код

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

Вычисляет сумму элементов этой коллекции.

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

Исходный код

def tail: Seq[A]

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

Исходный код

def tails: Iterator[Seq[A]]

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

Исходный код

def take(n: Int): Seq[A]

Исходный код

def takeRight(n: Int): Seq[A]

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

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

Исходный код

def takeWhile(p: A => Boolean): Seq[A]

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

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

Исходный код

override def tapEach[U](f: A => U): Seq[A]

Исходный код

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

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

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

Исходный код

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

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

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

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

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

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

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[A]

Исходный код

def transpose[B](implicit asIterable: A => Iterable[B]): Seq[Seq[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[A]

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

Исходный код

def unzip[A1, A2](implicit asPair: A => (A1, A2)): (Seq[A1], Seq[A2])

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

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

Source

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (Seq[A1], Seq[A2], Seq[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))

Source@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

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

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

Source

def updated[B >: A](index: Int, elem: B): Seq[B]

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

Source

override def view: SeqView[A]

Source

def withFilter(p: A => Boolean): WithFilter[A, Seq]

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

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

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

Source

def zip[B](that: IterableOnce[B]): Seq[(A, B)]

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

Source

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Seq[(A1, B)]

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

Source

def zipWithIndex: Seq[(A, Int)]