Класс scala.collection.mutable.ArrayDeque

class ArrayDeque[A] extends AbstractBuffer[A] with IndexedBuffer[A] with IndexedSeqOps[A, ArrayDeque, ArrayDeque[A]] with StrictOptimizedSeqOps[A, ArrayDeque, ArrayDeque[A]] with IterableFactoryDefaults[A, ArrayDeque] with ArrayDequeOps[A, ArrayDeque, ArrayDeque[A]] with Cloneable[ArrayDeque[A]] with DefaultSerializable

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

Добавление в конец, начало, удаление с начала, удаление с конца и произвольный доступ (индексированный поиск и замена) занимают амортизированное постоянное время. В общем случае удаление и вставка по i-ому индексу имеют сложность O(min(i, n-i)), поэтому вставки и удаления с начала/конца быстры.

Конструкторы

Исходный код

def this(initialSize: Int)

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

Исходный код

override def addAll(elems: IterableOnce[A]): ArrayDeque[A]

Исходный код

def addOne(elem: A): ArrayDeque[A]

Исходный код

def apply(idx: Int): A

Исходный код

def clear(): Unit

Примечание: Это не фактически изменяет размер внутренней структуры. Обратитесь к clearAndShrink, если нужно также изменить размер внутренне

Исходный код

def clearAndShrink(size: Int): ArrayDeque[A]

Очищает буфер и уменьшает его размер до @param size

Исходный код

override def copyToArray[B >: A](dest: Array[B], destStart: Int, len: Int): Int

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

def ensureSize(hint: Int): Unit

Исходный код

def insert(idx: Int, elem: A): Unit

Исходный код

def insertAll(idx: Int, elems: IterableOnce[A]): Unit

Исходный код

override def isEmpty: Boolean

Исходный код

override def iterableFactory: SeqFactory[ArrayDeque]

Исходный код

override def knownSize: Int

Исходный код

def length: Int

Source

def prepend(elem: A): ArrayDeque[A]

Source

override def prependAll(elems: IterableOnce[A]): ArrayDeque[A]

Source

def remove(idx: Int, count: Int): Единица

Source

def remove(idx: Int): A

Source

def removeAll(): Последовательность[A]

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

Source

def removeAll(p: A => Boolean): Последовательность[A]

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

Source

def removeAllReverse(): Последовательность[A]

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

Source

def removeFirst(p: A => Boolean, from: Int): Вариант[A]

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

Source

def removeHead(resizeInternalRepr: Boolean): A

Небезопасно удаляет первый элемент (выбрасывает исключение при пустоте). См. также removeHeadOption()

Source

def removeHeadOption(resizeInternalRepr: Boolean): Вариант[A]

Source

def removeHeadWhile(f: A => Boolean): Последовательность[A]

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

Source

def removeLast(resizeInternalRepr: Boolean): A

Небезопасно удаляет последний элемент (выбрасывает исключение при пустоте). См. также removeLastOption()

Source

def removeLastOption(resizeInternalRepr: Boolean): Вариант[A]

Source

def removeLastWhile(f: A => Boolean): Последовательность[A]

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

Source

override def stepper[S <: Счётчик[_]](implicit shape: ФормаСчётчика[A, S]): S & EfficientSplit

Source

override def subtractOne(elem: A): ArrayDeque[A]

Source

override def toArray[B >: A : ClassTag]: Массив[B]

Source

def trimToSize(): Единица

Уменьшает емкость экземпляра ArrayDeque до текущего размера.

Source

def update(idx: Int, elem: A): Единица

Наследуемые методы

Source@inline

final def ++[B >: A](suffix: IterableOnce[B]): ArrayDeque[B]

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

Source@inline

final override def ++:[B >: A](prefix: IterableOnce[B]): ArrayDeque[B]

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

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

final def ++=(xs: IterableOnce[A]): ArrayDeque[A]

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

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

final def ++=:(elems: IterableOnce[A]): ArrayDeque[A]

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

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

final def +:[B >: A](elem: B): ArrayDeque[B]

Псевдоним для prepended.

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

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

final def +=(elem: A): ArrayDeque[A]

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

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

final def +=:(elem: A): ArrayDeque[A]

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

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

final def --=(xs: IterableOnce[A]): ArrayDeque[A]

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

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

final def -=(elem: A): ArrayDeque[A]

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

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

final def :+[B >: A](elem: B): ArrayDeque[B]

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

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

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

final def :++[B >: A](suffix: IterableOnce[B]): ArrayDeque[B]

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

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

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой коллекции в строку-построитель. Записываемый текст состоит из строковых представлений (в соответствии с методом toString) всех элементов этой коллекции без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

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

final def addString(b: StringBuilder, sep: String): StringBuilder

Добавляет все элементы этой коллекции в строку-построитель с использованием разделительной строки. Записываемый текст состоит из строковых представлений (в соответствии с методом toString) всех элементов этой коллекции, разделённых строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Исходный код

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Добавляет все элементы этой коллекции в строку-построитель, используя начальную, конечную и разделительные строки. Записываемый текст начинается со строки start и заканчивается строкой end. Внутри строковые представления (в соответствии с методом toString) всех элементов этой коллекции разделяются строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Исходный код

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

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

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

Исходный код

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

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

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

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

final def append(elem: A): ArrayDeque[A]

Добавляет заданные элементы в этот буфер.

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

final def appendAll(xs: IterableOnce[A]): ArrayDeque[A]

Добавляет элементы, содержащиеся в итерируемом объекте, в этот буфер.

Исходный код

override def appended[B >: A](elem: B): ArrayDeque[B]

Исходный код

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

Исходный код

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. Это может привести к улучшению производительности и более предсказуемому поведению относительно побочных эффектов.

Исходный код

def canEqual(that: Any): Boolean

Исходный код

final override def clone(): ArrayDeque[A]

Исходный код

override def collect[B](pf: PartialFunction[A, B]): ArrayDeque[B]

Исходный код

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

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

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

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

Исходный код

def combinations(n: Int): Iterator[ArrayDeque[A]]

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

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

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

Исходный код

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

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

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

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

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def copySliceToArray(srcStart: Int, dest: Array[_], destStart: Int, maxItems: Int): dest.type

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

Исходный код@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник@deprecatedOverriding("Это должно всегда передавать в 3-аргументную версию этого метода", since = "2.13.4")

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Source

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

Source

def distinct: ArrayDeque[A]

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

Source

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

Source

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

Source

def dropInPlace(n: Int): ArrayDeque[A]

Source

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

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

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

Source

def dropRightInPlace(n: Int): ArrayDeque[A]

Source

def dropWhile(p: A => Boolean): ArrayDeque[A]

Source

def dropWhileInPlace(p: A => Boolean): ArrayDeque[A]

Source

def elementWise: ElementWiseExtractor[Int, A]

Возвращает объект-экстрактор с методом 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
}

Source

override def empty: ArrayDeque[A]

Source

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

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

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

Source

override def equals(o: Any): Boolean

Source

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

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

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

Source

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

Source

def filterInPlace(p: A => Boolean): ArrayDeque[A]

Source

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

Source

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

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

def flatMapInPlace(f: A => IterableOnce[A]): ArrayDeque[A]

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

def groupMap[K, B](key: A => K)(f: A => B): Map[K, ArrayDeque[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)(_ + _)

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

Источник

override def grouped(n: Int): Iterator[ArrayDeque[A]]

Источник

override def hashCode(): Int

Источник

override def head: A

Источник

override def headOption: Option[A]

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

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

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

Источник

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: ArrayDeque[A]

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

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

Исходный код

def inits: Iterator[ArrayDeque[A]]

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

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

Исходный код

override def intersect[B >: A](that: Seq[B]): ArrayDeque[A]

Исходный код

def isDefinedAt(idx: Int): Boolean

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

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

Исходный код

override def isTraversableAgain: Boolean

Исходный код

def iterator: Iterator[A]

Исходный код

override def last: A

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код

def lastOption: Option[A]

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

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

Исходный код

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, ArrayDeque[A]]

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

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без затрат на создание и деструкцию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Источник

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

Источник

final override def lengthCompare(len: Int): Int

Источник@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

Источник

def lift: Int => Option[A]

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

Источник

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

Источник

def mapInPlace(f: A => A): ArrayDeque[A]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Источник@inline

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

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

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

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

Источник

def padToInPlace(len: Int, elem: A): ArrayDeque[A]

Источник

override def partition(p: A => Boolean): (ArrayDeque[A], ArrayDeque[A])

Источник

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

Source

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

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

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

Source

def patchInPlace(from: Int, patch: IterableOnce[A], replaced: Int): ArrayDeque[A]

Source

def permutations: Iterator[ArrayDeque[A]]

Перебирает все различные перестановки.

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

Source

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

Source

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Источник

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

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

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

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

Источник@inline

final protected def requireBounds(idx: Int, until: Int): Unit

Источник

override def reverse: ArrayDeque[A]

Источник

override def reverseIterator: Iterator[A]

Источник

override protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

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

Являются ли элементы этого набора такими же (и в том же порядке), как и элементы that?

Источник

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

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

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

Источник

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

Источник

def scanRight[B](z: B)(op: (A, B) => B): ArrayDeque[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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

final override def size: Int

Источник

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

Источник

final override def sizeCompare(otherSize: Int): Int

Источник@inline

final def sizeIs: SizeCompareOps

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

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

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

Источник

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

Источник

def sliceInPlace(start: Int, end: Int): ArrayDeque[A]

Источник

override def sliding(window: Int, step: Int): Iterator[ArrayDeque[A]]

Источник

def sliding(size: Int): Iterator[ArrayDeque[A]]

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

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

Источник

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): ArrayDeque[A]

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Источник

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

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

Источник

def sortInPlaceBy[B](f: A => B)(implicit ord: Ordering[B]): ArrayDeque[A]

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

Источник

def sortInPlaceWith(lt: (A, A) => Boolean): ArrayDeque[A]

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

Источник

def sortWith(lt: (A, A) => Boolean): ArrayDeque[A]

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

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

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

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

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

Источник

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

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

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

Источник

override def span(p: A => Boolean): (ArrayDeque[A], ArrayDeque[A])

Источник

override def splitAt(n: Int): (ArrayDeque[A], ArrayDeque[A])

Источник

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

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

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

Источник

def subtractAll(xs: IterableOnce[A]): ArrayDeque[A]

Удаляет все элементы, сгенерированные итератором, из этой изменяемой коллекции.

Источник

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

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

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

Источник

def tail: ArrayDeque[A]

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

Источник

def tails: Iterator[ArrayDeque[A]]

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

Источник

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

Источник

def takeInPlace(n: Int): ArrayDeque[A]

Источник

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

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

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

Источник

def takeRightInPlace(n: Int): ArrayDeque[A]

Источник

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

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

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

Источник

def takeWhileInPlace(p: A => Boolean): ArrayDeque[A]

Источник

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

Источник

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

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

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

Источник@inline

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

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

def toList: List[A]

Источник

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

Источник

def toSeq: Seq[A]

Источник

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

Источник

override def toString(): String

Источник

def toVector: Vector[A]

Источник

def transpose[B](implicit asIterable: A => Iterable[B]): ArrayDeque[ArrayDeque[B]]

Транспонирует эту итерируемую коллекцию итерируемых коллекций в итерируемую коллекцию итерируемых коллекций.

Тип возвращаемой коллекции будет определяться статическим типом итерируемой коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

Источник

def unapply(a: Int): Option[A]

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

Источник

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

Источник

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

Источник

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

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

Источник

override def view: IndexedSeqView[A]

Источник

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

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

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

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

Источник

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

Источник

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

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

Источник

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