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

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

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

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

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

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

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

Создаёт новую коллекцию со всеми элементами этой коллекции за исключением elem.

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

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

Удаляет один элемент из этого буфера. Может занимать время, линейное относительно размера буфера.

Удаляет два или более элементов из этой сжимаемой коллекции.

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

Примечание: /: — это альтернативная запись для 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 преобразует каждый входной символ в Int и добавляет его к сумме (раздела). Затем combop просто нужно сложить промежуточные результаты разделов:

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

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

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

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

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

Пример:

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

scala> x(3)
res1: Int = 4

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

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

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

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

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

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

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

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

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

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

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

Копирует все элементы этой коллекции в буфер.

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

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

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

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

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

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

Выбирает все элементы, кроме первых 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)

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вставляет новые элементы в индекс n. В отличие от метода update, этот метод не заменяет элемент новым. Вместо этого он вставит новый элемент в индекс n.

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

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

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

Проверяет, пуст ли этот буфер списка.

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

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

Проверяет, можно ли многократно итерировать эту коллекцию перебираемых элементов.

Возвращает итератор по этому ListBuffer. Итератор будет отражать изменения, внесённые в базовый ListBuffer после следующего элемента; значение следующего элемента кешируется, чтобы hasNext и next гарантированно оставались согласованными. В частности, пустой ListBuffer вернёт пустой итератор, даже если ListBuffer заполнится позже.

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

Выполняется за константное время.

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

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

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

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

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

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

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

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

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

Выполняется за постоянное время.

Текущая длина буфера.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, не пуст ли буфер списка.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Перемножает элементы этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает накопленную List.

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

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

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

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

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

Примечание: 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).

Размер этого буфера списка.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает итератор по элементам в этой итерируемой коллекции. Возвращает тот же результат, что и iterator.

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

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

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

Преобразует это множество в последовательность. Как и toIterable, оно ленивое в этом базовом реализации, поскольку это TraversableOnce может быть ленивым и не вычисленным.

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

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

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

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

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

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

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

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

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

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

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

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

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

Удаляет последние n элементов этого буфера.

Удаляет первые n элементов этого буфера.

Объект итерируемого объекта, к которому передаются вызовы.

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

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

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

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

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

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

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

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

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

Объединяет этот буфер списка со своими индексами.