Тракт scala.collection.LinearSeq

тракт LinearSeq[+A] extends Seq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] with IterableFactoryDefaults[A, LinearSeq]

Базовый тракт для линейно доступных последовательностей, имеющих эффективные head и tail операции. Известные подклассы: List, LazyList

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

Исходный код

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

final def :++[B >: A](suffix: IterableOnce[B]): LinearSeq[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): LinearSeq[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]): LinearSeq[B]

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

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

override def apply(n: Int): A

Источник

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

Источник

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

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[LinearSeq[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]): LinearSeq[B]

Источник

override 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("Это всегда должно передавать в версию этого метода с 3 аргументами", 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]): LinearSeq[A]

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

Источник

def distinct: LinearSeq[A]

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

Источник

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

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

Источник

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

Источник

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

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

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

Источник

def dropWhile(p: A => Boolean): LinearSeq[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: LinearSeq[A]

Источник

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

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

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

Источник

override def equals(o: Any): Boolean

Источник

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

Источник

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

Источник

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

Источник

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

Источник

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

Источник

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

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

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

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

Источник

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

Источник

override def hashCode(): Int

Источник

def head: A

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

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

Источник

override def headOption: Option[A]

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

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

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

Source

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

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

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

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

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

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

Source

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

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

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

Source

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

Source@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

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

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

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

Source

def indices: Range

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

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

Исходный код

def init: LinearSeq[A]

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

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

Исходный код

def inits: Iterator[LinearSeq[A]]

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

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

Исходный код

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

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

Исходный код

override def isDefinedAt(x: Int): Boolean

Исходный код

override def isEmpty: Boolean

Исходный код

override def isTraversableAgain: Boolean

Исходный код

def iterator: Iterator[A]

Source

def knownSize: Int

Source

override def last: A

Source

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

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

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

Source@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Source

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

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

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

Source

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

Source@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Source

def lastOption: Option[A]

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, LinearSeq[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)

Source

def length: Int

Source

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

Source

override def lengthCompare(len: Int): Int

Source@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

Source

def lift: Int => Option[A]

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

Source

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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, который может быть переопределён.

Source

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

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

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

Source

protected def newSpecificBuilder: Builder[A, LinearSeq[A]]

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Source

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

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

Source

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

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

Source

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

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

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

Source

def partitionMap[A1, A2](f: A => Either[A1, A2]): (LinearSeq[A1], LinearSeq[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 >: A](from: Int, other: IterableOnce[B], replaced: Int): LinearSeq[B]

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

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

Source

def permutations: Iterator[LinearSeq[A]]

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

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

Source

def prepended[B >: A](elem: B): LinearSeq[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)

Source

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

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

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

Исходный код

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]

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def reverse: LinearSeq[A]

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

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

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

Source

def reverseIterator: Iterator[A]

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

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

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

Source

protected def reversed: Iterable[A]

Source

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 избегает двойной оценки совпадений шаблонов и условий для литералов частичных функций.

Источник

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

Источник

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

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

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

Источник

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

Источник

def scanRight[B](z: B)(op: (A, B) => B): LinearSeq[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 перед вызовом; в противном случае результаты неопределённы.

Источник

override 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): LinearSeq[A]

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Сортировка стабильная. То есть элементы, которые равны (как определено 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): LinearSeq[A]

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

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

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

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

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

Источник

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

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

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

Источник

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

Источник

override def splitAt(n: Int): (LinearSeq[A], LinearSeq[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: LinearSeq[A]

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

Источник

override def tails: Iterator[LinearSeq[A]]

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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]): LinearSeq[LinearSeq[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)): (LinearSeq[A1], LinearSeq[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: A => (A1, A2, A3)): (LinearSeq[A1], LinearSeq[A2], LinearSeq[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))

Исходный код

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

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

Исходный код

override def view: SeqView[A]

Исходный код

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

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

def zipWithIndex: LinearSeq[(A, Int)]