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

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

Эквивалентно 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)

добавляет все элементы, произведённые TraversableOnce, в это изменяемый коллекцию.

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

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

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

Пример:

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)

Добавляет один элемент в конец этого буфера. Эта операция занимает постоянное время.

Добавляет два или более элементов в эту изменяемую коллекцию.

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

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

Примечание: /: — это альтернативная синтаксическая конструкция для 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)

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

Примечание: :\ — это альтернативная запись для 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).

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

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

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

Обратите внимание, что выражение 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]] не вызовет. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, соответствуют ли содержимое списка требуемому типу.

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

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

Создает копию объекта-приемника.

По умолчанию реализация метода clone зависит от платформы.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Добавляет все элементы в очередь.

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Список пуст?

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

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

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

Возвращает итератор по максимум length элементам этого списка.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Библиотека, которая строит экземпляры типа mutable.Queue[A]

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

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

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

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

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

Возвращает параллельную реализацию этой коллекции.

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

Специфические коллекции (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая использует тот же базовый набор данных. Для этих коллекций метод par выполняется за постоянное или подлинейное время.

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

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

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

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

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

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

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

Умножает элементы этого набора.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Коллекция типа обходной коллекции, лежащей в основе этого 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.

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

Указывает, что ожидается, что result этого билдера будет иметь тот же размер, что и заданная коллекция, плюс некоторое значение дельты. Это предоставит подсказку только в том случае, если известно, что у коллекции есть метод size с низкой стоимостью. В настоящее время предполагается, что это так, если и только если коллекция имеет тип IndexedSeqLike. Некоторые классы билдеров оптимизируют свою структуру на основе подсказки. Однако реализации билдеров по-прежнему должны работать правильно, даже если подсказка неверна, т. е. добавлено разное количество элементов.

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

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

Указывает, сколько элементов ожидается добавить при следующем вызове result. Некоторые классы билдеров оптимизируют свою структуру на основе подсказки. Однако реализации билдеров по-прежнему должны работать правильно, даже если подсказка неверна, т. е. добавлено разное количество элементов.

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

Сортировка устойчива. То есть, элементы, которые равны (как определяется 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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-й элемент этого списка новым значением.

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

Создаёт нестрогую (non-strict) представление среза (slice) этой последовательности.

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

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

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

Создаёт нестрогое (non-strict) фильтрующее представление этой коллекции.

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

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

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

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

Объединяет эту изменяемую очередь с её индексами.