Класс scala.collection.Concat

@SerialVersionUID(3L)

class Concat[A](prefix: SomeSeqOps[A], suffix: SomeSeqOps[A]) extends Concat[A] with SeqView[A]

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

Исходный код

def apply(idx: Int): A

Исходный код

def length: Int

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

Исходный код@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): SeqView[B]

Исходный код

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

Исходный код

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

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

Исходный код

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

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

Источник

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

Источник

override def dropRight(n: Int): SeqView[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

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

protected def fromSpecific(coll: IterableOnce[A]): 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]]

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

Исходный код

def head: A

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

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

Исходный код

def headOption: Option[A]

Возвращает опционально первый элемент.

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

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

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

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

Исходный код

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: Представление[A]

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

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

Источник

def inits: Итератор[Представление[A]]

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

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

Источник

def intersect[B >: A](that: Последовательность[B]): Представление[A]

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

Источник

def isDefinedAt(idx: Целое): Булево

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

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

Источник

override def isEmpty: Булево

Источник

override def isTraversableAgain: Булево

Источник

override def iterableFactory: IterableFactory[Представление]

Источник

def iterator: Итератор[A]

Источник

override def knownSize: Целое

Источник

def last: A

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

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

Источник

def lastIndexOf[B >: A](elem: B, end: Целое): Целое

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

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

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

def lastIndexOfSlice[B >: A](that: Seq[B]): Целое

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

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

Источник

def lastIndexOfSlice[B >: A](that: Seq[B], end: Целое): Целое

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

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

Источник@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Источник

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

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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

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

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

Источник

def lengthCompare(len: Int): Int

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

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

Источник@inline

final def lengthIs: SizeCompareOps

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

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

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Исходный код

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

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

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

Исходный код

protected def newSpecificBuilder: Builder[A, 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): SeqView[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: SeqView[A]

Исходный код

def reverseIterator: Iterator[A]

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

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

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

Исходный код

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)

Исходный код

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

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

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

Исходный код

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

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

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

Источник

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

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

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

Источник

final def segmentLength(p: A => Boolean): Int

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

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

Источник

final override def size: Int

Источник

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

Источник

final override def sizeCompare(otherSize: Int): Int

Источник@inline

final def sizeIs: SizeCompareOps

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

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

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

Источник

def slice(from: Int, until: Int): View[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])

Источник

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

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

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

Источник

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

Возвращает scala.collection.Stepper для элементов этого набора.

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

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

• Для наборов, содержащих Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для наборов, содержащих Double или Float, возвращается scala.collection.DoubleStepper

• Для наборов, содержащих Long, возвращается scala.collection.LongStepper

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

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

Источник

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

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

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

Источник

def tail: View[A]

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

Источник

def tails: Iterator[View[A]]

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

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

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

def toList: List[A]

Источник

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

Источник

def toSeq: Seq[A]

Источник

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

Источник

override def toString: String

Источник

def toVector: Vector[A]

Источник

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

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

Источник

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

Источник

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

Источник

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

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

Источник

override def view: SeqView[A]

Источник

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

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

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

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

Источник

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

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

Источник

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

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

Source

def zipWithIndex: View[(A, Int)]