Класс StringView.StringView

final case class StringView(s: String) extends AbstractIndexedSeqView[Char]

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

Исходный код

def apply(n: Int): Char

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

Исходный код

def length: Int

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

Исходный код

override def toString: String

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

final def :++[B >: Char](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 >: Char](elem: B): IndexedSeqView[B]

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

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

Пример:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Исходный код

def appendedAll[B >: Char](suffix: SomeIndexedSeqOps[B]): IndexedSeqView[B]

Исходный код

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Source

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

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

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

Source

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

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

Source

def distinct: C

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

Source

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

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

Source

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

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

Source

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

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

Источник

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

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

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

Источник

override def empty: View[A]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

def flatMap[B](f: Char => 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: Char => 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 >: Char](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

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

Исходный код

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

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

Источник

override def head: A

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

Источник

override def headOption: Option[A]

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

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

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

override def iterableFactory: IterableFactory[View]

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

Источник

override def iterator: Iterator[A]

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

Источник

override def knownSize: Int

Источник

override def last: A

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

Источник

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def lastIndexWhere(p: Char => 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)

Источник

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

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

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

Источник

final override def lengthCompare(len: Int): Int

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def mkString: String

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

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

Source

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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

Источник

def nonEmpty: Boolean

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

Источник

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

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

Источник

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

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

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

Source

def partitionMap[A1, A2](f: Char => Either[A1, A2]): (CC[A1], CC[A2])

Применяет функцию f к каждому элементу итерируемого набора и возвращает пару итерируемых наборов: первый набор содержит значения, возвращённые функцией f, заключенные в scala.util.Left, а второй — значения, заключённые в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Source

def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): CC[B]

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

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

Source

def permutations: Iterator[C]

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

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

Source

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

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

Source

def prependedAll[B >: Char](prefix: SomeIndexedSeqOps[B]): IndexedSeqView[B]

Source

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

Source

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

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

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

Source

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

Перемножает элементы этого набора.

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

Source

def productElementNames: Iterator[String]

Итератор по именам всех элементов этого произведения.

Source

def productIterator: Iterator[Any]

Итератор по всем элементам этого произведения.

Source

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

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

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

Source

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

override def reverse: IndexedSeqView[A]

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

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

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

Источник

override def reverseIterator: Iterator[A]

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

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

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

Источник

override protected def reversed: Iterable[A]

Источник

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

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

Источник

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

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

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

Источник

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

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

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

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

Source

def scanRight[B](z: B)(op: (Символ, B) => B): CC[B]

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

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

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

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

Пример:

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

Source

override def search[B >: Символ](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

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

Source

override def search[B >: Символ](elem: B)(implicit ord: Ordering[B]): SearchResult

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

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

Source

def segmentLength(p: Символ => Boolean, from: Int): Int

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

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

Source

final def segmentLength(p: Символ => 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

Источник

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

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

from <= indexOf(x) < until

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

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

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

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Исходный код

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Символ, S]): S & EfficientSplit

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

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

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

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

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

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

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

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

Исходный код

def sum[B >: Символ](implicit num: Numeric[B]): B

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

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

Исходный код

def tail: C

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

Исходный код

def tails: Iterator[C]

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

Исходный код

override def take(n: Целое): IndexedSeqView[A]

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

Исходный код

override def takeRight(n: Целое): IndexedSeqView[A]

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

Исходный код

def takeWhile(p: Символ => Boolean): C

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

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

Исходный код

override def tapEach[U](f: Символ => U): IndexedSeqView[A]

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

Исходный код

def to[C1](factory: Factory[Символ, C1]): C1

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

Примеры использования:

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

Исходный код

def toArray[B >: Символ : ClassTag]: Массив[B]

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

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

Исходный код

final def toBuffer[B >: Символ]: Буфер[B]

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

def toVector: Vector[A]

Source

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

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

Source

def unzip[A1, A2](implicit asPair: Char => (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))

Source

def unzip3[A1, A2, A3](implicit asTriple: Char => (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))

Source

def updated[B >: Char](index: Int, elem: B): CC[B]

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

Source

override def view: IndexedSeqView[A]

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

Source

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

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

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

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

Source

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

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

Source

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

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

Source

def zipWithIndex: CC[(A, Int)]

Объединяет эту итерируемую коллекцию с ее индексами.