Особенность scala.collection.immutable.LinearSeqOps

trait LinearSeqOps[+A, +CC <: (LinearSeq), +C <: LinearSeq[A] & LinearSeqOps[A, CC, C]] extends SeqOps[A, CC, C] with LinearSeqOps[A, CC, C]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

override def apply(n: Int): A

Источник

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

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[C]

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

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

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

Источник@inline

final override def concat[B >: A](suffix: IterableOnce[B]): CC[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("Это должно всегда передавать вызов к 3-аргументной версии этого метода", 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: Seq[B])(p: (A, B) => Boolean): Boolean

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

Источник

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

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

def distinct: C

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

Исходный код

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

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

Исходный код

def drop(n: Int): C

Исходный код

def dropRight(n: Int): C

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

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

Исходный код

def dropWhile(p: A => Boolean): C

Исходный код

def empty: C

Пустая итерируемая коллекция того же типа, что и эта итерируемая коллекция

Исходный код

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

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

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

Исходный код

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

Исходный код

def filter(pred: A => Boolean): C

Исходный код

def filterNot(pred: A => Boolean): C

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

def flatten[B](implicit asIterable: A => IterableOnce[B]): CC[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

Источник

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

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

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

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

Источник

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

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

Источник

def head: A

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

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

Источник

override 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

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

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

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

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

Source

def init: C

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

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

Source

def inits: Iterator[C]

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

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

Source

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

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

Source

override def isDefinedAt(x: Int): Boolean

Source

override def isEmpty: Boolean

Source

override def isTraversableAgain: Boolean

Source

def iterableFactory: IterableFactory[CC]

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

Source

def iterator: Iterator[A]

Source

def knownSize: Int

Источник

override 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

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

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

Источник

override def lastIndexWhere(p: A => Boolean, 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 lastOption: Option[A]

Возможный выбор последнего элемента.

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

Источник

def length: Int

Источник

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

Источник

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 map[B](f: A => B): CC[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, который может быть переопределён.

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

def nonEmpty: Boolean

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

Исходный код

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

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

Исходный код

def partition(p: A => Boolean): (C, C)

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

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

Исходный код

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

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

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

Исходный код

def permutations: Iterator[C]

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

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

Исходный код

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def reverse: C

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

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

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

Источник

def reverseIterator: Iterator[A]

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

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

Источник

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

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

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

Источник

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

Источник

def scanRight[B](z: B)(op: (A, B) => B): CC[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): C

Источник

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

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

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

Источник

def sliding(size: Int): Iterator[C]

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

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

Источник

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

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

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

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def span(p: A => Boolean): (C, C)

Источник

override def splitAt(n: Int): (C, C)

Источник

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. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Stepper могут быть преобразованы только в последовательные потоки.

Источник

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

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

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

Источник

def tail: C

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

Источник

override def tails: Iterator[C]

Источник

def take(n: Int): C

Источник

def takeRight(n: Int): C

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

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

Источник

def takeWhile(p: A => Boolean): C

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

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

Источник

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

Источник

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]

Источник

def toVector: Vector[A]

Источник

def transpose[B](implicit asIterable: A => Iterable[B]): CC[CC[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 unzip[A1, A2](implicit asPair: A => (A1, A2)): (CC[A1], CC[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)): (CC[A1], CC[A2], CC[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): CC[B]

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

Источник

override def view: SeqView[A]

Источник

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

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

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

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

Источник

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

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

Источник

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

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

Источник

def zipWithIndex: CC[(A, Int)]