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

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для чисел возвращает хэш-значение, согласованное с равенством по значению: если два экземпляра типа значения сравниваются как true, то ## будет генерировать одинаковое хэш-значение для каждого из них. Для null возвращает хэш-код, где null.hashCode вызывает NullPointerException.

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

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

Поскольку у TraversableOnce нет метода ++, мы должны реализовать его напрямую, но Traversable и далее могут использовать перегруз.

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

Копия стека с добавленным элементом в начало.

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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

Примечание: /: — альтернативная синтаксическая конструкция для foldLeft; z /: xs — то же самое, что и xs foldLeft z.

Примеры:

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

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

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

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

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

Мнемоника для +: по сравнению с :+: двоеточие идёт со стороны коллекции.

Пример:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

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

Примечание: :\ — альтернативная синтаксическая конструкция для foldRight; xs :\ z — то же самое, что и xs foldRight z.

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

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

Примеры:

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

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

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

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

Пример:

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

Добавляет все элементы этого перебираемого объекта или итератора в строковый буфер с использованием разделителя. Записанный текст состоит из строковых представлений (относительно метода 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

Добавляет все элементы этого перебираемого объекта или итератора в строковый буфер, используя начальную, конечную и разделительные строки. Записанный текст начинается со строки 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)

Агрегирует результаты применения оператора к последующим элементам.

Это более общий вид fold и reduce. Похож на foldLeft, так как не требует, чтобы результат был супертипом типа элемента. Кроме того, он позволяет обрабатывать параллельные коллекции частями, а затем объединяет промежуточные результаты.

aggregate разбивает перебираемый объект или итератор на разделы и обрабатывает каждый раздел последовательным применением seqop, начиная с z (как foldLeft). Затем эти промежуточные результаты объединяются с помощью combop (как fold). Реализация этой операции может работать с произвольным количеством разделов коллекции (даже 1), поэтому combop может вызываться произвольное количество раз (даже 0).

В качестве примера рассмотрим суммирование целочисленных значений списка символов. Начальное значение суммы равно 0. Сначала seqop преобразует каждый символ ввода в целое число и добавляет его к сумме (раздела). Затем combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

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

Возвращает n-й элемент из стека, где вершина стека имеет индекс 0.

Это операция с линейным временем.

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

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

Преобразует получаемый объект к типу T0.

Обратите внимание, что успех преобразования во время выполнения зависит от стирания типов в Scala. Поэтому выражение 1.asInstanceOf[String] выбросит ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] не выбросит. В последнем примере, поскольку тип аргумента стирается на этапе компиляции, невозможно проверить, соответствуют ли содержимое списка требуемому типу.

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

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

Этот метод клонирует стек.

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

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

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

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

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

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

Объект-компаньон фабрики, который создаёт экземпляры класса Stack. (или его Iterable суперкласса, где класс Stack не является Seq.)

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

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

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

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

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

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

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

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

Копирует все элементы этого обходимого или итератора в буфер.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, является ли переданный аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на не-нулевых экземплярах AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых не-нулевых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого не-нулевого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить, чтобы их поведение соответствовало ссылке на равенство. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и они должны иметь одинаковое значение хеширования (o1.hashCode == o2.hashCode).

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

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

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

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

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

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

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

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

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

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

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

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Преобразует этот стек итерируемых наборов в стек, образованный элементами этих итерируемых наборов.

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

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

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

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

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

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

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

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

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

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

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

Применяет функцию f ко всем элементам этого стека.

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

Возвращает строку, отформатированную в соответствии с заданной format строкой. Форматные строки аналогичны String.format (@см java.lang.String.format).

Неявный конструктор, который создаёт экземпляры Traversable для произвольных типов элементов.

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

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

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

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

Проверяет, известен ли размер этого итерируемого набора как конечный. Все строгие наборы известны как конечного размера. Для нестрогого набора, например, Stream, предикат возвращает true если все элементы были вычислены. Возвращает false , если поток еще не оценен до конца. Непустые итераторы обычно возвращают false даже если они были созданы из набора с известным конечным размером.

Примечание: многие методы наборов не будут работать с наборами бесконечного размера. Типичный режим отказа — бесконечный цикл. Эти методы всегда пытаются выполнить проход без предварительной проверки, что hasDefiniteSize возвращает true. Однако проверка hasDefiniteSize может гарантировать, что размер определен и бесконечная итерация не является проблемой.

Хеш-коды для GenSeq генерируют значение из хеш-кодов всех элементов общего последовательности.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверьте, является ли динамический тип объекта получателя T0.

Обратите внимание, что результат теста производится по модулю семантики стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, в то время как выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, соответствуют ли элементы списка указанному типу.

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

Возвращает итератор по всем элементам стека. Этот итератор стабилен по отношению к изменениям состояния объекта стека; т. е. такие изменения не будут отражаться в итераторе. Итератор выдает элементы в обратном порядке их вставки в стек (LIFO-порядок).

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

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

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

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

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

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

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

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

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

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

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

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

Количество элементов в стеке.

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

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

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

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

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

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

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

Отображает все элементы этого перебираемого объекта или итератора в строке.

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

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

Эквивалентно !(this eq that).

Построитель, который создает экземпляры типа Traversable[A]

Проверяет, не пуст ли перебираемый объект или итератор.

Разбуждает единственную нить, которая ожидает монитора объекта-получателя.

Разбуждает все нити, которые ожидают монитора объекта-получателя.

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

A copy of this stack with an element value appended until a given target length is reached.

Returns a parallel implementation of this collection.

For most collection types, this method creates a new parallel collection by copying all the elements. For these collection, par takes linear time. Mutable collections in this category do not produce a mutable parallel collection that has the same underlying dataset, so changes in one collection will not be reflected in the other one.

Specific collections (e.g. ParArray or mutable.ParHashMap) override this default behaviour by creating a parallel collection which shares the same underlying dataset. For these collections, par takes constant or sublinear time.

All parallel collections return a reference to themselves.

The default par implementation uses the combiner provided by this method to create a new parallel collection.

Partitions this traversable collection in two traversable collections according to a predicate.

Produces a new stack where a slice of elements in this stack is replaced by another sequence.

Iterates over distinct permutations.

Removes the top element from the stack.

Returns the length of the longest prefix whose elements all satisfy some predicate.

Note: may not terminate for infinite-sized collections.

Multiplies up the elements of this collection.

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

Поместить элемент в стек.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Коллекция типа Traversable, лежащая в основе этого TraversableLike объекта. По умолчанию это сам объект TraversableLike, но это можно переопределить.

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

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

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

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

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

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

Примечание: xs.reverseMap(f) то же самое, что и xs.reverse.map(f), но может быть более эффективным.

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

Версия этого набора с выполнением всех операций последовательно (т.е. в однопоточном режиме).

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

Размер этой последовательности, эквивалентный length.

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

Размер этого набора или итератора, если он может быть вычислен без больших затрат

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

Примечание: c span p эквивалентно (но, возможно, более эффективно), чем (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

Разделяет эту коллекцию прохода по данным на две части по заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно), чем (c take n, c drop n).

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

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

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

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

Определяет префикс представления toString этого объекта.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает это итерируемое множество как итерируемое множество.

Новая коллекция не будет построена; ленивые коллекции останутся ленивыми.

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

Возвращает итератор над элементами в этом итерируемом множестве. Производит тот же результат, что и iterator.

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

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

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

Преобразует эту последовательность в последовательность.

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

Новая коллекция не будет построена; в частности, ленивые последовательности останутся ленивыми.

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

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

Преобразует это итерируемое множество в поток.

Преобразует эту последовательность в строку.

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

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

Преобразует эту коллекцию итераций или итератор в вектор.

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

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

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

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

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

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

Создаёт новую последовательность, содержащую все элементы этого стека и также все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это заключается в том, что xs union ys вычисляет многомножественное объединение с сохранением порядка элементов xs и ys. union является, таким образом, аналогом diff и intersect, которые также работают с многомножествами.

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

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

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

val xs = Traversable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three),
//        Traversable(1, 2, 3))

Заменяет элемент по индексу n новым элементом newelem.

Это операция с линейным временем.

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

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

Примечание: разница между view и slice в том, что view создаёт вид текущей последовательности, а slice создаёт новую последовательность.

Примечание: view(from, to) эквивалентно view.slice(from, to)

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

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

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

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

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

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

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