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

sealed class Queue[+A] extends AbstractSeq[A] with LinearSeq[A] with LinearSeqOps[A, Queue, Queue[A]] with StrictOptimizedLinearSeqOps[A, Queue, Queue[A]] with StrictOptimizedSeqOps[A, Queue, Queue[A]] with IterableFactoryDefaults[A, Queue] with DefaultSerializable

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

Queue реализована как пара List списков, один содержит элементы очереди для добавления, а другой — для извлечения. Элементы добавляются в список добавления и удаляются из списка извлечения. Когда список извлечения пуст, очередь поворачивается путем замены списка извлечения на обратный список добавления, а список добавления — на пустой список.

Добавление элементов в очередь всегда имеет стоимость O(1). Удаление элементов имеет стоимость O(1), за исключением случая, когда требуется поворот, в этом случае возникает стоимость O(n), где n — количество элементов в очереди. Когда это происходит, n операций удаления со стоимостью O(1) гарантированы. Удаление элемента в среднем имеет стоимость O(1).

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

Исходный код

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

Исходный код

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

Исходный код

override def apply(n: Int): A

Возвращает n-й элемент этой очереди. Первый элемент находится по позиции 0.

Исходный код

def dequeue: (A, Queue[A])

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

Исходный код

def dequeueOption: Option[(A, Queue[A])]

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

Исходный код

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

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

Исходный код

def enqueueAll[B >: A](iter: Iterable[B]): Queue[B]

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

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

Исходный код

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

Исходный код

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

Исходный код

def front: A

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

Исходный код

override def head: A

Исходный код

override def isEmpty: Boolean

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

Исходный код

override def iterableFactory: SeqFactory[Queue]

Исходный код

override def iterator: Iterator[A]

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

Исходный код

override def last: A

Исходный код

override def length: Int

Возвращает длину очереди.

Исходный код

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

Исходный код

override def tail: Queue[A]

Исходный код

override def toString(): String

Возвращает строковое представление этой очереди.

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

Исходный код@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 +:[B >: A](elem: B): Queue[B]

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

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

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

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

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

final def :++[B >: A](suffix: IterableOnce[B]): Queue[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 (обратите внимание на его предостережения).

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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]

Source

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

Source

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

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

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

Source

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Источник

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

Источник

def distinct: Queue[A]

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

Источник

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

Source

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

Source

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

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

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

Source

override def dropWhile(p: A => Boolean): Queue[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: Queue[A]

Source

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

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

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

Source

override def equals(o: Any): Boolean

Source

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

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

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

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

Источник

override def hashCode(): Int

Источник

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("Замените indexWhere(p, from) вместо - indexWhere(p) вызывает indexWhere(p, 0)", "2.13.0")

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

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

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

Исходный код

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

Исходный код

def indices: Range

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

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

Исходный код

def init: Queue[A]

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

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

Исходный код

def inits: Iterator[Queue[A]]

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

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

Исходный код

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

Исходный код

override def isDefinedAt(x: Int): Boolean

Исходный код

override def isTraversableAgain: Boolean

Исходный код

def knownSize: Int

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Замените lastIndexOfSlice(that, end) вместо - lastIndexOfSlice(that) вызывает 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

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

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

Source

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

Source

def lastOption: Option[A]

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

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

Source

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)

Source

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

Source

override def lengthCompare(len: Int): Int

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

Source

def lift: Int => Option[A]

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

Source

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

Source

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

Находит максимальный элемент.

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

Source

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

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

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

Source

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

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

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

Source

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

Находит максимальный элемент.

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

Source

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

Исходный код@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): Queue[B]

Исходный код

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

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

Source

def permutations: Iterator[Queue[A]]

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

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

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

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

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

Source

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

def reverse: Очередь[A]

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

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

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

Исходный код

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

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

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

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

Исходный код

protected def reversed: Итерируемая[A]

Исходный код

def runWith[U](action: A => U): Целое => Булево

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

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

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

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

Исходный код

override def sameElements[B >: A](that: IterableOnce[B]): Булево

Исходный код

def scan[B >: A](z: B)(op: (B, B) => B): Очередь[B]

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

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

Исходный код

override def scanLeft[B](z: B)(op: (B, A) => B): Очередь[B]

Исходный код

def scanRight[B](z: B)(op: (A, B) => B): Очередь[B]

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

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

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

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

Пример:

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

Исходный код

def search[B >: A](elem: B, from: Целое, to: Целое)(implicit ord: Ordering[B]): SearchResult

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

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

Исходный код

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

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

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

Исходный код

override def segmentLength(p: A => Булево, from: Целое): Целое

Source

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

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

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

Source

final override def size: Int

Source

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

Source

final override def sizeCompare(otherSize: Int): Int

Source@inline

final def sizeIs: SizeCompareOps

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

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

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

Source

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

Source

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

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

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

Source

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

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

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

Source

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 sortWith(lt: (A, A) => Boolean): Queue[A]

Сортирует этот набор в соответствии с функцией сравнения.

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

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

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

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

Source

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

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

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

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

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

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

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

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

• Для коллекций Long возвращается scala.collection.LongStepper

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

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

Source

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

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

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

Source

override def tails: Iterator[Queue[A]]

Source

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

Source

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

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

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

Source

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

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

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

Source

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

Source

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

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

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

Source

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

Преобразовать коллекцию в массив.

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

Source@inline

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

Source

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: Очередь[A]

Source

def toSet[B >: A]: Множество[B]

Source

def toVector: Вектор[A]

Source

def transpose[B](implicit asIterable: A => Iterable[B]): Очередь[Очередь[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: Целое число): Некоторые[A]

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

Source

override def unzip[A1, A2](implicit asPair: A => (A1, A2)): (Очередь[A1], Очередь[A2])

Source

override def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (Очередь[A1], Очередь[A2], Очередь[A3])

Source

override def updated[B >: A](index: Целое число, elem: B): Очередь[B]

Source

override def view: SeqView[A]

Source

def withFilter(p: A => Булево): WithFilter[A, Очередь]

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

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

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

Source

override def zip[B](that: IterableOnce[B]): Очередь[(A, B)]

Source

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Очередь[(A1, B)]

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

Source

override def zipWithIndex: Очередь[(A, Целое число)]