Класс scala.collection.Drop

@SerialVersionUID(3L)

class Drop[A](underlying: SomeIndexedSeqOps[A], n: Int) extends Drop[A] with IndexedSeqView[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Исходный код

override def appended[B >: A](elem: B): IndexedSeqView[B]

Исходный код

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

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

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

def apply(i: Int): A

Источник

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

Источник

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

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

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

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

Источник

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

Перебирает сочетания. _Сочетание_ длины 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]

Источник@inline

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

def distinct: View[A]

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

Исходный код

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

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

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

override def empty: View[A]

Исходный код

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

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

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

Исходный код

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

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

Источник

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

Источник

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

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

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

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

Источник

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

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

Исходный код

override 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

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

Исходный код

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

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

Исходный код@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: View[A]

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

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

Source

def inits: Iterator[View[A]]

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

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

Source

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

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

Source

def isDefinedAt(idx: Int): Boolean

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

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

Source

override def isEmpty: Boolean

Source

override def isTraversableAgain: Boolean

Source

override def iterableFactory: IterableFactory[View]

Source

override def iterator: Iterator[A]

Source

override 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@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Source

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

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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

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

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

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

Источник

def length: Int

Источник

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

Источник

final override def lengthCompare(len: Int): Int

Источник@inline

final def lengthIs: SizeCompareOps

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

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

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

Источник

override def map[B](f: A => B): IndexedSeqView[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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source@inline

final def mkString: String

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

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

Source@inline

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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

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

def nonEmpty: Boolean

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Исходный код

def permutations: Iterator[View[A]]

Перебирает различные перестановки.

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

Исходный код

override def prepended[B >: A](elem: B): IndexedSeqView[B]

Исходный код

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

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

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

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

Исходный код

override def reverse: IndexedSeqView[A]

Исходный код

override def reverseIterator: Iterator[A]

Исходный код

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

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

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

Источник

def sortWith(lt: (A, A) => Boolean): View[A]

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

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

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

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

Источник

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

Источник

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

Source

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

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

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

Source

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

Source

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

Суммирует элементы этого набора.

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

Source

def tail: View[A]

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

Source

def tails: Iterator[View[A]]

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

Source

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

Source

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

Source

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

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

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

Source

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

Source

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

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

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

Source

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

Преобразовать коллекцию в массив.

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

override def toString: String

Source

def toVector: Vector[A]

Source

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

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

Source

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

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

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

Source

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (View[A1], View[A2], View[A3])

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

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

Source

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

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

Source

override def view: IndexedSeqView[A]

Source

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

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

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

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

Source

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

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

Source

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

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

Source

def zipWithIndex: View[(A, Int)]