Класс SeqView.Id

class Id[+A](underlying: SomeSeqOps[A]) extends AbstractSeqView[A]

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

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

Исходный код

def apply(idx: Int): A

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

Исходный код

override def isEmpty: Boolean

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

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

Исходный код

def iterator: Iterator[A]

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

Исходный код

override def knownSize: Int

Исходный код

def length: Int

Длина (количество элементов) последовательности. size является псевдонимом для length в коллекциях Seq.

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

Исходный код

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): SeqView[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: SeqOps[B, AnyConstr, _]): SeqView[B]

Источник

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

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

Источник

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: SeqOps[B, AnyConstr, _]): SeqView[B]

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

Источник

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

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

Источник

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

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

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

Источник

override def empty: View[A]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

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

Source

def groupMap[K, B](key: A => K)(f: A => B): Map[K, CC[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Это эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

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

Источник

def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B]

Разбивает этот итерируемый набор на карту по функции-дискриминатору key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются функцией f и затем сводятся к одному значению с помощью функции reduce.

Это эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

Источник

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

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

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

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

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

Source

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 isTraversableAgain: Boolean

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

Исходный код

override def iterableFactory: IterableFactory[View]

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

Исходный код

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

Источник

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]

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

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

Источник

final def mkString: String

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

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

Источник

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, 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 к каждому элементу iterable коллекции и возвращает пару iterable коллекций: первая содержит значения, возвращённые 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): SeqView[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: SeqOps[B, AnyConstr, _]): SeqView[B]

Source

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

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

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

Source

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

Перемножает элементы этой коллекции.

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

id="reduceRight-fffff3d4"> Источник

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

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

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

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

id="reduceRightOption-8fe"> Источник

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

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

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

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

id="reverse-0"> Источник

override def reverse: SeqView[A]

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

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

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

id="reverseIterator-0"> Источник

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

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

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

Источник

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

Создаёт итерируемый набор, содержащий кумулятивные результаты применения оператора слева направо, включая начальное значение.

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

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

Источник

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

Создаёт набор, содержащий кумулятивные результаты применения оператора справа налево. Голова набора — последний кумулятивный результат.

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

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

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

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

Источник

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

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

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

Источник

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

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

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

Источник

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

Сравнивает размер этого набора с размером другого набора Iterable.

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

Источник

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

Источник

final def sizeIs: SizeCompareOps

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

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

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

Источник

def slice(from: Int, until: Int): C

Выбирает интервал элементов. Возвращаемый итерируемый набор состоит из всех элементов 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), появляются в отсортированной последовательности в том же порядке, что и в исходной.

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

Возвращает scala.collection.Stepper для элементов этой коллекции.

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

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

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

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

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

Source

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

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

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

Source

def tail: C

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

Source

def tails: Iterator[C]

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

Применяет функцию с побочным эффектом к каждому элементу в этой коллекции. Строгие коллекции немедленно применяют f к своим элементам, тогда как ленивые коллекции, такие как представления и ленивые списки, применяют 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: SeqView[A]

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

Исходный код

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

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

def zipWithIndex: CC[(A, Int)]

Комбинирует этот итерируемый набор с его индексами.