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

@migration("Stack теперь основан на ArrayDeque вместо связанного списка", "2.13.0")

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

Стек реализует структуру данных, которая позволяет хранить и извлекать объекты в порядке «последним вошел — первым вышел» (LIFO).

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

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

Исходный код

def this(initialSize: Int)

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

Исходный код

override def iterableFactory: SeqFactory[Stack]

Исходный код

def pop(): A

Удаляет верхний элемент из этого стека и возвращает его

Исходный код

def popAll(): Seq[A]

Извлекает все элементы из этого стека и возвращает их

Исходный код

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

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

Исходный код

def push(elem: A): Stack[A]

Добавляет элементы в начало стека

Исходный код

def push(elem1: A, elem2: A, elems: A*): Stack[A]

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

Исходный код

def pushAll(elems: IterableOnce[A]): Stack[A]

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

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

final def top: A

Возвращает верхний элемент стека. Этот метод не удаляет элемент из стека. Ошибка сигнализируется, если в стеке нет элементов.

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

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

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

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

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

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

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

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

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

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

Источник@inline

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

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

Источник@inline

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

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

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

Источник@inline

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

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

Источник

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

Источник

def addOne(elem: A): Stack[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 на результирующей частичной функции может применить первую частичную функцию и выполнить её побочное действие. Для повышения эффективности рекомендуется вместо isDefinedAt или apply использовать applyOrElse.

Источник

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

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник

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

Источник

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

Источник

def apply(idx: Int): A

Источник

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

Источник

def clear(): Unit

Примечание: Это не фактически изменяет размер внутреннего представления. Используйте clearAndShrink, если нужно также изменить размер внутреннего представления

Источник

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

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

Источник

final override def clone(): Stack[A]

Источник

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

Источник

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

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

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

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

Параметры значения

Возвращает

значение Option, содержащее примененную pf к первому значению, для которого она определена, или None, если такового не существует.

Пример

Seq("a", 1, 5L).collectFirst({ case x: Int => x*10 }) = Some(10)

Источник

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

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

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

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

Возвращает

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

Пример

"abbbc".combinations(2) = Iterator(ab, ac, bb, bc)

Источник

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]): Stack[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: Массив[B], destStart: Целое число, len: Целое число): Целое число

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

def copyToArray[B >: A](xs: Массив[B], start: Целое число): Целое число

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

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

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

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

def copyToArray[B >: A](xs: Массив[B]): Целое число

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (A, B) => Булево): Булево

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

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

Источник

def corresponds[B](that: Seq[B])(p: (A, B) => Булево): Булево

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

Source

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

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

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

Source

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

Source

def distinct: Stack[A]

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

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

Source

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

Source

def dropWhileInPlace(p: A => Boolean): Stack[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: Stack[A]

Source

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

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

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

Source@inline

def ensureSize(hint: Int): Unit

Source

override def equals(o: Any): Boolean

Source

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

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

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

Source

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

Source

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

Source

override def filterNot(pred: A => Boolean): Stack[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]): Stack[B]

Source

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

Source

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

Source

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

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

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

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

Источник

def groupMap[K, B](key: A => K)(f: A => B): Map[K, Stack[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[Stack[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: Диапазон

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

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

Источник

def init: Стек[A]

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

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

Источник

def inits: Итератор[Стек[A]]

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

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

Источник

def insert(idx: Целое, elem: A): Единица

Источник

def insertAll(idx: Целое, elems: IterableOnce[A]): Единица

Источник

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

Источник

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

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

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

Источник

override def isEmpty: Булево

Источник

override def isTraversableAgain: Булево

Источник

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

Источник

override def knownSize: Целое

Источник

override def last: A

Источник

def lastIndexOf[B >: A](elem: B, end: Целое): Целое

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

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

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Источник

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

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

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

Source@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Source

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

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

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

Source

def lastOption: Option[A]

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Stack[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

def length: Int

Source

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

Source

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

Source

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

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

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, Stack[A]]

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

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

Source

def permutations: Iterator[Stack[A]]

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

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

Source

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

Source

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

Source

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

Source

override def prependedAll[B >: A](prefix: IterableOnce[B]): Stack[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 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]

Source

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

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

Source

def removeLast(resizeInternalRepr: Boolean): A

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

Source

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

Source

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

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

Source@inline

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

Source

override def reverse: Stack[A]

Source

override def reverseIterator: Iterator[A]

Source

override protected def reversed: Iterable[A]

Source

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

Source

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

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

Source

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

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

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

Source

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

Source

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

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

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

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

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

Пример:

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

Source

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

Source

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

Исходный код

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

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

Источник

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

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

Источник

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

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

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

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

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

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

Источник

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

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

Источник

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

Источник

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

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

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

Источник

def tail: Stack[A]

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

Источник

def tails: Iterator[Stack[A]]

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

Источник

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

Источник

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

Source

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

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

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

Source

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

Source

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

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

def toSeq: Seq[A]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[A]

Source

def transpose[B](implicit asIterable: A => Iterable[B]): Stack[Stack[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 trimToSize(): Unit

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

Source

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

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

Source

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

Исходный код

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

Исходный код

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

Исходный код

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

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

Исходный код

override def view: IndexedSeqView[A]

Исходный код

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

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

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

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

Исходный код

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

Исходный код

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

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

Исходный код

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