Класс AbstractIndexedSeqView.AbstractIndexedSeqView

абстрактный класс AbstractIndexedSeqView[+A] extends AbstractSeqView[A] с IndexedSeqView[A]

Явное создание экземпляра IndexedSeqView для уменьшения размера файлов классов в подклассах.

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

Исходный код

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)

Исходный код

override def appended[B >: A](elem: B): IndexedSeqView[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: SomeIndexedSeqOps[B]): IndexedSeqView[B]

Исходный код

def appendedAll[B >: A](suffix: SeqOps[B, AnyConstr, _]): SeqView[B]

Исходный код

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

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

Источник

def apply(i: Int): A

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

Источник

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

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

Источник

def concat[B >: A](suffix: SomeIndexedSeqOps[B]): IndexedSeqView[B]

Источник

def concat[B >: A](suffix: SeqOps[B, AnyConstr, _]): SeqView[B]

Источник

final override def concat[B >: A](suffix: IterableOnce[B]): CC[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 элементов.

Источник

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

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

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

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

Источник

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]): C

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

Источник

def distinct: C

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

Источник

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

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

Источник

override def drop(n: Int): IndexedSeqView[A]

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

Источник

override def dropRight(n: Int): IndexedSeqView[A]

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

Источник

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

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

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

Source

override def empty: View[A]

Пустой итератор того же типа, что и этот итератор

Source

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

Source

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

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

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

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

Source

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

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

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

Источник

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующей коллекции определяется статическим типом итерируемой коллекции. Это может иногда приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Источник

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

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

Определяет, как преобразовать заданную Iterable[A] в коллекцию типа C.

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

Источник

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]

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

Источник

override def head: A

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

Источник

override def headOption: Option[A]

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

def indices: Range

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

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

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

Проверяет, можно ли эту итерируемую коллекцию многократно проходить. Всегда true для Iterables и false для Iterators, если не переопределено.

Источник

override def iterableFactory: IterableFactory[View]

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

Источник

override def iterator: Iterator[A]

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

Источник

override def knownSize: Int

Источник

override def last: A

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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, Iterable]

Аналогично 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.

Source

final override 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

Source

final override def lengthCompare(len: Int): Int

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

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

Source

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

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

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

Source

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

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

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

Source

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]

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

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

Источник

final def mkString: String

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

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

Источник

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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

Источник

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]

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

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

Источник

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

Источник

def prependedAll[B >: A](prefix: SeqOps[B, AnyConstr, _]): SeqView[B]

Источник

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

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

Отличается от :++ тем, что тип результирующей коллекции определяется правым операндом, а не левым. Мемоническая подсказка: знак COLon стоит со стороны нового типа 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]

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

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

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

Источник

override def reverse: IndexedSeqView[A]

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

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

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

Источник

override def reverseIterator: Iterator[A]

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

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

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

Источник

override protected def reversed: Iterable[A]

Источник

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

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

Источник

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)

Источник

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

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

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

Источник

override 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

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

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

Source

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

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

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

Source

final override def sizeCompare(otherSize: Int): Int

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

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Source

final def sizeIs: SizeCompareOps

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

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

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

Источник

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

Выбирает интервал элементов. Возвращаемый вид состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

Источник

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

Источник

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

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

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

Источник

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

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

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

Источник

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

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Источник

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

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

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

Источник

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

Возвращает 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: C

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

Исходный код

def tails: Iterator[C]

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

Исходный код

override def take(n: Int): IndexedSeqView[A]

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

Исходный код

override def takeRight(n: Int): IndexedSeqView[A]

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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 из этого метода.

Исходный код

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]): 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: IndexedSeqView[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)]

Объединяет этот итерируемый набор со своими индексами.