Трейт scala.collection.mutable.IndexedBuffer

Добавляет один элемент в это расширяемое множество.

Получить элемент по указанному индексу. Эта операция предоставляется для удобства в Seq. Не следует предполагать, что она эффективна, если у вас нет IndexedSeq.

Очищает содержимое коллекции. После этой операции коллекция пуста.

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

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

Длина (количество элементов) последовательности. size является псевдонимом для length в Seq коллекциях.

Добавляет один элемент в начало этого уменьшаемого множества.

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

Удаляет элемент по заданному индексу.

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

Проверить два объекта на неравенство.

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

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

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что операторы с окончанием :- являются правоассоциативными (см. пример). Мемоническое правило для +: против :+ таково: ДВОЕТОЧИЕ относится к стороне СОБРАНИЯ.

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

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

Добавляет все элементы, полученные из IterableOnce, в этот набор.

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

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

Обратите внимание, что вызов isDefinedAt на полученной частичной функции может применить первую частичную функцию и выполнить ее побочный эффект. Сильно рекомендуется использовать applyOrElse вместо isDefinedAt / apply для повышения эффективности.

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

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

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

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

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

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

Пример:

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)

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

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

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

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

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

Рекомендуется возвращать имя конкретного типа коллекции, но не подклассы реализации. Например, для ListMap этот метод должен возвращать "ListMap", а не "Map" (супертип) или "Node" (подкласс реализации).

По умолчанию реализация возвращает "Iterable". Она переопределяется для основных типов коллекций "Seq", "IndexedSeq", "LinearSeq", "Buffer", "Set", "Map", "SortedSet", "SortedMap" и "View".

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что вызов isDefinedAt на результирующей частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Сильно рекомендуется использовать applyOrElse вместо isDefinedAt / apply для повышения эффективности.

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

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

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

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

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

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

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

Заполняет данный массив xs начиная с индекса start не более чем len элементами этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

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

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

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

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

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

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

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

Универсальный метод равенства, определенный в AnyRef.

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

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

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

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

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

Детали времени и условия вызова метода 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: String) => 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)

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

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

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

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

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

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

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

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

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

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

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

Применить f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи выводу типа scalac.

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

Определяет, как преобразовать заданный Iterable[A] в коллекцию типа C.

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

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

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

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

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией дискриминатора key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

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

Разделяет эту итерируемую коллекцию на карту в соответствии с функцией дискриминатора key. Все значения, имеющие один и тот же дискриминатор, затем преобразуются функцией value и сводятся к одному значению с помощью функции reduce.

Эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, является ли последовательность пустой.

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

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

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

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

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

Итератор можно использовать только один раз

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

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

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

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

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

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

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

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

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

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

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

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

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

Аналогично zip, за исключением того, что элементы в каждом наборе не потребляются до тех пор, пока не вызовется строгое действие над возвращаемым LazyZip2 декоратором.

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без затрат на создание и деконструкцию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Сравнивает длину этого набора с размером другого Iterable.

Сравнивает длину этого набора со значением-тестом.

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

Эти операции реализованы с использованием lengthCompare(Int), и позволяют использовать более удобочитаемые конструкции:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

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

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

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

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

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

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

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

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

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

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

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

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

Делегирует addString, который можно переопределить.

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

Делегирует addString, который можно переопределить.

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

Делегирует addString, который можно переопределить.

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

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

Разбуживает единственный поток, который ожидает монитора объекта-приёмника.

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

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

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

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

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

Применяет функцию f к каждому элементу итерируемой коллекции и возвращает пару итерируемых коллекций: первая состоит из тех значений, которые возвращаются f и были обернуты в scala.util.Left, а вторая — из тех, которые были обернуты в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

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

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

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

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

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

Кроме того, исходная последовательность не изменяется, поэтому вам нужно сохранить результат.

Пример:

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

Последовательность должна быть отсортирована с помощью того же Ordering перед вызовом; в противном случае результаты не определены.

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

Последовательность должна быть отсортирована с помощью того же Ordering перед вызовом; в противном случае результаты не определены.

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

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

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

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

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

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

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

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

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

Эти операции реализуются с помощью sizeCompare(Int) и позволяют использовать более читаемые выражения:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

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

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

Возвращает Stepper для элементов этого набора.

Stepper позволяет создавать поток Java для работы с набором, см. scala.jdk.StreamConverters. Для наборов, содержащих примитивные значения, Stepper можно использовать как итератор, который не упаковывает элементы.

Неявный параметр StepperShape определяет тип результирующего Stepper в соответствии с типом элементов этого набора.

Для наборов, содержащих Int, Short, Byte или Char, возвращается IntStepperДля наборов, содержащих Double или Float, возвращается DoubleStepperДля наборов, содержащих Long, возвращается LongStepperДля любого другого типа элемента возвращается AnyStepper

Обратите внимание, что этот метод переопределяется в подклассах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, IndexedSeqOps.stepper. Для Steppers, отмеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Steppers могут быть преобразованы только в последовательные потоки.

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

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

Суммирует элементы этого набора.

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

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

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

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

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

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

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

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

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

Преобразовать коллекцию в массив.

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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

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

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 элементов этого буфера.

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

Преобразует необязательную функцию в частичную функцию.

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

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

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

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

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

Представление элементов этой коллекции.

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

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

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

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

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

Объединяет эту итерируемую коллекцию с ее индексами.