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

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

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

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

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

A copy of this synchronized queue with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Example:

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)

Applies a binary operator to all elements of this traversable or iterator and a start value, going right to left.

Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

Appends all elements of this traversable or iterator to a string builder. The written text consists of the string representations (w.r.t. the method toString) of all elements of this traversable or iterator without any separator string.

Example:

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

Appends all elements of this traversable or iterator to a string builder using a separator string. The written text consists of the string representations (w.r.t. the method toString) of all elements of this traversable or iterator, separated by the string sep.

Example:

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

Appends all elements of this traversable or iterator to a string builder using start, end, and separator strings. The written text begins with the string start and ends with the string end. Inside, the string representations (w.r.t. the method toString) of all elements of this traversable or iterator are separated by the string sep.

Example:

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

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

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

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

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

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

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

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

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

Возвращает строку, отформатированную в соответствии с заданной строкой форматирования. Строки форматирования такие же, как для String.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.

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

Указывает, что ожидается, что размер этого билдера будет таким же, как у заданной коллекции, плюс некоторая величина delta. Это будет учтено, только если у коллекции есть метод `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)) становится парой ключ-значение в карте. Повторные ключи будут перезаписаны более поздними ключами: если это неупорядоченная коллекция, то какой ключ находится в результирующей карте, не определено.

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

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

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

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

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

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

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

Преобразует эту итерируемую коллекцию в неопределенное 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-й элемент этого списка на новое значение.

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

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

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

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

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

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

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

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

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

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

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