Трейт scala.collection.mutable.ArrayDequeOps

Трейт ArrayDequeOps[A, +CC[_], +C <: AnyRef] extends StrictOptimizedSeqOps[A, CC, C]

Абстрактные методы

Исходный код

Защищенный метод array: Array[AnyRef]

Исходный код

Защищенный метод klone(): C

Исходный код

Защищенный метод ofArray(array: Array[AnyRef], end: Int): C

Исходный код

Защищенный метод start_+(idx: Int): Int

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

Исходный код

Окончательный переопределенный метод clone(): C

Исходный код

Метод copySliceToArray(srcStart: Int, dest: Array[_], destStart: Int, maxItems: Int): dest.type

Это более общая версия copyToArray - она также принимает srcStart в отличие от copyToArray. Это копирует maxItems элементов из этого набора srcStart в dest's destStart. Если мы достигнем конца любого из наборов данных, прежде чем сможем скопировать maxItems, мы просто прекратим копирование.

Исходный код

Переопределенный метод grouped(n: Int): Iterator[C]

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

Окончательный защищенный метод requireBounds(idx: Int, until: Int): Unit

Исходный код

Переопределенный метод reverse: C

Исходный код

Переопределенный метод slice(from: Int, until: Int): C

Исходный код

Переопределенный метод sliding(window: Int, step: Int): Iterator[C]

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

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

Окончательный метод ++[B >: A](suffix: IterableOnce[B]): CC[B]

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

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

Окончательный переопределенный метод ++:[B >: A](prefix: IterableOnce[B]): CC[B]

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

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

Окончательный метод +:[B >: A](elem: B): CC[B]

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

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

Окончательный метод :+[B >: A](elem: B): CC[B]

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

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

Окончательный метод :++[B >: A](suffix: IterableOnce[B]): CC[B]

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

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

Окончательный метод 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

Окончательный метод 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 и разделитель. Записываемый текст начинается со строки 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): CC[B]

Исходный код

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

Исходный код@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def apply(i: Int): A

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Source@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 значениями из этого набора.

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

Source@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 значениями из этого набора.

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

Исходный код

def distinct: C

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

Исходный код

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

Исходный код

def drop(n: Int): C

Исходный код

override def dropRight(n: Int): C

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

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

Исходный код

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

Исходный код

def empty: C

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

Исходный код

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

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

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.

Исходный код

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

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

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

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

Исходный код

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

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

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

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

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

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

Исходный код

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

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

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

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

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

Исходный код

def 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: Диапазон

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

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

Источник

def init: C

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

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

Источник

def inits: Итератор[C]

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

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

Источник

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

Источник

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

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

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

Источник

override def isEmpty: Булево

Источник

override def isTraversableAgain: Булево

Источник

def iterableFactory: IterableFactory[CC]

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

Источник

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

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

Источник

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: Последовательность[B]): Целое

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

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

Источник

def lastIndexOfSlice[B >: A](that: Последовательность[B], end: Целое): Целое

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

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

Источник@deprecatedOverriding("Override lastIndexWhere(p, end) вместо - lastIndexWhere(p) вызывает 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 length: Int

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

Источник

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): CC[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, которые могут быть переопределены.

Исходный код@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Исходный код

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

Исходный код

override def partition(p: A => Boolean): (C, C)

Исходный код

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

Source

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

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

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

Source

def permutations: Iterator[C]

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

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

Source

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

Source

override 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

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

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

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

Исходный код

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]

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

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

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

Источник

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 может применяться более одного раза.

Источник

override 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

Source

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

Source

final override def sizeCompare(otherSize: Int): Int

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

Source

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

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

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

Source

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)

Source

def sortWith(lt: (A, A) => Boolean): C

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

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

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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. Для шагов, помеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные шаги могут быть преобразованы только в последовательные потоки.

Исходный код

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

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

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

Исходный код

def tail: C

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

Исходный код

def tails: Iterator[C]

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

Исходный код

def take(n: Int): C

Исходный код

override def takeRight(n: Int): C

Набор, содержащий последние n элементы этого набора.

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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]

Исходный код

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

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

Источник

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

Источник

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

Источник

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 операций.

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

Источник

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

Источник

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

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

Источник

override def zipWithIndex: CC[(A, Int)]