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

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

Queue объекты реализуют структуры данных, которые позволяют вставлять и извлекать элементы в порядке очереди (FIFO).

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

Исходный код

def this(initialSize: Int)

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

Исходный код

def dequeue(): A

Удаляет и возвращает первый элемент из очереди

Исходный код

def dequeueAll(p: A => Boolean): Seq[A]

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

Исходный код

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

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

Исходный код

def dequeueWhile(f: A => Boolean): Seq[A]

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

Исходный код

def enqueue(elem: A): Queue[A]

Добавляет элементы в конец очереди

Исходный код

def enqueue(elem1: A, elem2: A, elems: A*): Queue[A]

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

Исходный код

def enqueueAll(elems: IterableOnce[A]): Queue[A]

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

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

final def front: A

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

Исходный код

override def iterableFactory: SeqFactory[Queue]

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

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

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

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

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

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

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

Источник@inline

final def ++=(xs: IterableOnce[A]): Очередь[A]

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

Источник@inline

final def ++=:(elems: IterableOnce[A]): Очередь[A]

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

Источник@inline

final def +:[B >: A](elem: B): Очередь[B]

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

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

Источник@inline

final def +=(elem: A): Очередь[A]

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

Источник@inline

final def +=:(elem: A): Очередь[A]

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

Источник@inline

final def --=(xs: IterableOnce[A]): Очередь[A]

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

Источник@inline

final def -=(elem: A): Очередь[A]

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

Источник@inline

final def :+[B >: A](elem: B): Очередь[B]

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

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

Источник@inline

final def :++[B >: A](suffix: IterableOnce[B]): Очередь[B]

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

Источник

override def addAll(elems: IterableOnce[A]): Очередь[A]

Источник

def addOne(elem: A): Очередь[A]

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

Source

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

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

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

Source@inline

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

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

Source@inline

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

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

Source

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

Source

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

Source

def apply(idx: Int): A

Source

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

Source

def canEqual(that: Any): Boolean

Source

def clear(): Unit

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

Source

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

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

Source

final override def clone(): Queue[A]

Source

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

Source

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

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

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

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

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

Source

def combinations(n: Int): Iterator[Queue[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]): Queue[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 элементов, мы просто останавливаем копирование.

Исходный код

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

Исходный код@deprecatedOverriding("Это должно всегда перенаправлять на 3-аргументную версию этого метода", 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

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

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

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

Source

def distinct: Queue[A]

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

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

Исходный код

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

Исходный код

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

Исходный код

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
}

Исходный код

override def empty: Queue[A]

Исходный код

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

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

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

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

def ensureSize(hint: Int): Unit

Исходный код

override def equals(o: Any): Boolean

Исходный код

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

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

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

Source

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

Source

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

Source

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

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

Source

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

Source

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

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

Source

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

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

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

Source

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

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

Source

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

Source

def groupBy[K](f: A => K): Map[K, Очередь[A]]

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

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

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

Source

def groupMap[K, B](key: A => K)(f: A => B): Map[K, Очередь[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)

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

Source

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)(_ + _)

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

Source

override def grouped(n: Целое): Итератор[Очередь[A]]

Source

override def hashCode(): Целое

Source

override def head: A

Source

override def headOption: Option[A]

Source@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B >: A](elem: B): Целое

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

Source

def indexOf[B >: A](elem: B, from: Целое): Целое

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

Source@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

def indexOfSlice[B >: A](that: Seq[B]): Целое

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

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

Source

def indexOfSlice[B >: A](that: Seq[B], from: Целое): Целое

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

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

Source@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

def indexWhere(p: A => Булево): Целое

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: Queue[A]

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

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

Источник

def inits: Iterator[Queue[A]]

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

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

Источник

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

Источник

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

Источник

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

def iterator: Iterator[A]

Источник

override def knownSize: Int

Источник

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("Замените 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 lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Queue[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)

Источник

def length: Int

Источник

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

Источник

def mapInPlace(f: A => A): Queue[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, Queue[A]]

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Source

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

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

Source

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

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

Source

def permutations: Iterator[Queue[A]]

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

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

Source

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

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]

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

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

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

Источник

def remove(idx: Int): A

Источник

def remove(idx: Int, count: Int): Unit

Источник

def removeAll(p: A => Boolean): Seq[A]

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

Источник

def removeAll(): Seq[A]

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

Источник

def removeAllReverse(): Seq[A]

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

Источник

def removeFirst(p: A => Boolean, from: Int): Option[A]

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

Источник

def removeHead(resizeInternalRepr: Boolean): A

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

Исходный код

def removeHeadOption(resizeInternalRepr: Boolean): Option[A]

Исходный код

def removeHeadWhile(f: A => Boolean): Seq[A]

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

Исходный код

def removeLast(resizeInternalRepr: Boolean): A

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

Исходный код

def removeLastOption(resizeInternalRepr: Boolean): Option[A]

Исходный код

def removeLastWhile(f: A => Boolean): Seq[A]

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

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

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

Исходный код

override def reverse: Queue[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): Queue[B]

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

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

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

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

Исходный код

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

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

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

Исходный код

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Queue[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)

Source

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

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

Source

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

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

Source

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

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

Source

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

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

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

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

Source

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

Source

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

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

Source

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

Source

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

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

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

Source

def tail: Queue[A]

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

Source

def tails: Iterator[Queue[A]]

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

Источник@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]): Queue[Queue[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 trimToSize(): Unit

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

Источник

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

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

Источник

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

Источник

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

Источник

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

Источник

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

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

Источник

override def view: IndexedSeqView[A]

Источник

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

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

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

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

Источник

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

Источник

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

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

Источник

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