Класс ArraySeq.ArraySeq

sealed abstract class ArraySeq[+A] extends AbstractSeq[A] with IndexedSeq[A] with IndexedSeqOps[A, ArraySeq, ArraySeq[A]] with StrictOptimizedSeqOps[A, ArraySeq, ArraySeq[A]] with EvidenceIterableFactoryDefaults[A, ArraySeq, ClassTag] with Serializable

Неизменяемый массив.

Обеспечивает эффективную индексированную доступность и имеет небольшой размер памяти.

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

Исходный код

def apply(i: Int): A

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

Исходный код

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, 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 unsafeArray: Array[_]

Обёрнутый изменяемый Array в основе этого ArraySeq. Любые изменения в этом массиве нарушат ожидаемую неизменяемость. Его тип элемента не обязательно должен быть равен типу элемента этого ArraySeq. Примитивный ArraySeq может быть основан на массиве упакованных значений, а ссылка ArraySeq может быть основана на массиве супертипа или подтипа типа элемента.

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

Исходный код

override def appended[B >: A](elem: B): ArraySeq[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)

Исходный код

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

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

Исходный код

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

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

override def iterableFactory: SeqFactory[ArraySeq]

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

Источник

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

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

Источник

override def prepended[B >: A](elem: B): ArraySeq[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)

Источник

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

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

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

Источник

override def reverse: ArraySeq[A]

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

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

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

Источник

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

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

from <= indexOf(x) < until

Исходный код

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

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

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

Исходный код

override def tail: ArraySeq[A]

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

Исходный код

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

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

Исходный код

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

Коллекция, содержащая последние n элементы этой коллекции.

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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)

Исходный код

def andThen[C](k: PartialFunction[A, C]): PartialFunction[A, C]

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

Обратите внимание, что вызов isDefinedAt для результирующей частичной функции может применить первую частичную функцию и выполнить её побочное действие. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Исходный код

override def andThen[C](k: A => C): PartialFunction[A, C]

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

Если тип функции в момент выполнения является PartialFunction, то используется другой метод andThen (см. его предостережения).

Исходный код

def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: A1 => B1): B1

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

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

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

- объединение частичных функций в цепочки orElse/andThen не приводит к избыточной оценке apply/isDefinedAt - lift и unlift не оценивают исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условным применением действий

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

Исходный код

override def canEqual(that: Any): Boolean

Метод, который должен вызываться из каждой хорошо спроектированной функции equals, которая может быть переопределена в подклассе. См. Programming in Scala, Глава 28 для обсуждения и проектирования.

Исходный код

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

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

Исходный код

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, B]

Компонует другую частичную функцию k с этой частичной функцией, так что эта частичная функция применяется к результатам k.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Исходный код

def compose[A](g: A => Int): A => R

Компонует две инстанции Function1 в новую Function1, при этом эта функция применяется последней.

Исходный код

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

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

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

Источник

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

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

Источник

def distinct: C

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

Источник

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

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

Источник

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

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

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

Источник

def elementWise: ElementWiseExtractor[A, B]

Возвращает объект экстрактора с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Исходный код

override def empty: CC[A]

Пустой итерируемый объект того же типа, что и этот итерируемый объект.

Исходный код

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

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

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

Исходный код

override def equals(o: Any): Boolean

Метод универсального равенства, определенный в AnyRef.

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

Источник

override def flatten[B](implicit toIterableOnce: 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 forall(p: A => Boolean): Boolean

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

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

Источник

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

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

Источник

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

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

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

Источник

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 grouped(size: Int): Iterator[C]

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

Источник

override def hashCode(): Int

Вычисляет хэш-код объекта.

Алгоритм хэширования зависит от платформы.

Возможны ситуации, когда два объекта имеют одинаковый хэш-код (o1.hashCode.equals(o2.hashCode)) но не равны (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true), то у них одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода убедитесь, что поведение согласуется с методом equals.

Источник

override def head: A

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

Источник

override def headOption: Option[A]

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

override def intersect[B >: A](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

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

Источник

def iterator: Iterator[A]

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

Источник

override def knownSize: Int

Источник

override def last: A

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

Источник

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

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

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

Источник

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

def lastOption: Option[A]

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

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

Source

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)

Source

def length: Int

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

Source

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

Source

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

Source

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

Source

def lift: A => Option[B]

Преобразует эту частичную функцию в обычную функцию, возвращающую результат Option.

Source

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

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

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

Source

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

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

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

Источник

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

Источник

def nonEmpty: Boolean

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

Источник

def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Источник

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

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

Источник

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

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

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

Источник

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

Исходный код

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

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

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

Исходный код

def permutations: Iterator[C]

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

override def reverseIterator: Iterator[A]

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

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

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

Исходный код

override protected def reversed: Iterable[A]

Исходный код

def runWith[U](action: A => U): A => Boolean

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

Исходный код

override def sameElements[B >: A](o: 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)

Исходный код

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

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

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

Исходный код

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

Сортирует эту последовательность в соответствии с 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: (A, A) => Boolean): C

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

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

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

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

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

Исходный код

override def span(p: A => 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 >: A](that: IterableOnce[B], offset: Int): Boolean

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

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

Source

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

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

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

Source

def tails: Iterator[C]

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

Source

final override def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

final override def toSeq: Seq.this.type

Source

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

Source

override def toString(): String

Возвращает строковое представление объекта.

Представление по умолчанию зависит от платформы.

Source

def toVector: Vector[A]

Source

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

Попытка извлечения B из A в выражении соответствия шаблонам.

Исходный код

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

Исходный код

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

Исходный код

override def view: IndexedSeqView[A]

Представление над элементами этого множества.

Исходный код

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

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

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

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

Исходный код

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

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

Исходный код

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

Объединяет это итерируемое множество с его индексами.