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

Трейт Buffer[A] extends Seq[A] with SeqOps[A, Buffer, Buffer[A]] with Growable[A] with Shrinkable[A] with IterableFactoryDefaults[A, Buffer]

A Buffer — это изменяемый и сжимаемый Seq.

Абстрактные методы

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def insert(idx: Int, elem: A): Unit

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def insertAll(idx: Int, elems: IterableOnce[A]): Unit

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

Источник

def patchInPlace(from: Int, patch: IterableOnce[A], replaced: Int): Buffer[A]

Источник

def prepend(elem: A): Buffer[A]

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def remove(idx: Int): A

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException]) @throws(scala.throws.$lessinit$greater$default$1[scala.IllegalArgumentException])

def remove(idx: Int, count: Int): Unit

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

Конкретные методы

Источник@inline

final def ++=:(elems: IterableOnce[A]): Buffer[A]

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

Источник@inline

final def +=:(elem: A): Buffer[A]

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

Источник@inline

final def append(elem: A): Buffer[A]

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

Источник@inline

final def appendAll(xs: IterableOnce[A]): Buffer[A]

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

Источник

def dropInPlace(n: Int): Buffer[A]

Источник

def dropRightInPlace(n: Int): Buffer[A]

Источник

def dropWhileInPlace(p: A => Boolean): Buffer[A]

Source

override def iterableFactory: SeqFactory[Buffer]

Source

override def knownSize: Int

Source

def padToInPlace(len: Int, elem: A): Buffer[A]

Source

def prependAll(elems: IterableOnce[A]): Buffer[A]

Source

def sliceInPlace(start: Int, end: Int): Buffer[A]

Source

def subtractOne(x: A): Buffer[A]

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

Source

def takeInPlace(n: Int): Buffer[A]

Source

def takeRightInPlace(n: Int): Buffer[A]

Source

def takeWhileInPlace(p: A => Boolean): Buffer[A]

Наследованные методы

Source@inline

final def ++[B >: A](suffix: IterableOnce[B]): Buffer[B]

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

Source@inline

final override def ++:[B >: A](prefix: IterableOnce[B]): Buffer[B]

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

Source@inline

final def ++=(xs: IterableOnce[A]): Buffer[A]

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

Source@inline

final def +:[B >: A](elem: B): Buffer[B]

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

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

Source@inline

final def +=(elem: A): Buffer[A]

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

Source@inline

final def --=(xs: IterableOnce[A]): Buffer[A]

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

Source@inline

final def -=(elem: A): Buffer[A]

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

Source@inline

final def :+[B >: A](elem: B): Buffer[B]

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

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

Source@inline

final def :++[B >: A](suffix: IterableOnce[B]): Buffer[B]

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

Source

def addAll(xs: IterableOnce[A]): Buffer[A]

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

Source

def addOne(elem: A): Buffer[A]

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

Source@inline

final def addString(b: StringBuilder): StringBuilder

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

Source@inline

final def addString(b: StringBuilder, sep: String): StringBuilder

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

Source

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

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

Source

def andThen[C](k: PartialFunction[A, C]): PartialFunction[Int, C]

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

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

Source

override def andThen[C](k: A => C): PartialFunction[Int, C]

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

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

Source

def appended[B >: A](elem: B): Buffer[B]

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

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

Пример:

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)

Исходный код

def appendedAll[B >: A](suffix: IterableOnce[B]): Buffer[B]

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

Исходный код@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def apply(i: Int): A

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

Исходный код

def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: A1 => B1): B1

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

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

Исходный код

def canEqual(that: Any): Boolean

Исходный код

def clear(): Unit

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

Source

override def clone(): Буфер[A]

Source

def collect[B](pf: ЧастичнаяФункция[A, B]): Буфер[B]

Source

def collectFirst[B](pf: ЧастичнаяФункция[A, B]): Option[B]

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

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

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

Source

def combinations(n: Целое): Итератор[Буфер[A]]

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

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

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

Source

def compose[R](k: ЧастичнаяФункция[R, Целое]): ЧастичнаяФункция[R, A]

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

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

Source@unspecialized

def compose[A](g: A => Целое): A => A

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

Source@inline

final override def concat[B >: A](suffix: IterableOnce[B]): Буфер[B]

Source

def contains[A1 >: A](elem: A1): Булево

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

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

Source

def containsSlice[B >: A](that: Seq[B]): Булево

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

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

Source

def copyToArray[B >: A](xs: Массив[B], start: Целое, len: Целое): Целое

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: A](xs: Массив[B], start: Целое): Целое

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

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: A](xs: Array[B]): Int

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean

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

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

Источник

def corresponds[B](that: Seq[B])(p: (A, B) => Boolean): Boolean

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

Источник

def count(p: A => Boolean): Int

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

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

Источник

def diff[B >: A](that: Seq[B]): Buffer[A]

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

Source

def distinct: Buffer[A]

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

Source

def distinctBy[B](f: A => B): Buffer[A]

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

Source

def drop(n: Int): Buffer[A]

Source

def dropRight(n: Int): Buffer[A]

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

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

Source

def dropWhile(p: A => Boolean): Buffer[A]

Source

def elementWise: ElementWiseExtractor[Int, A]

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

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Source

override def empty: Buffer[A]

Источник

def endsWith[B >: A](that: Iterable[B]): Boolean

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

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

Источник

override def equals(o: Any): Boolean

Источник

def exists(p: A => Boolean): Boolean

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

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

Источник

def filter(pred: A => Boolean): Buffer[A]

Источник

def filterNot(pred: A => Boolean): Buffer[A]

Источник

def find(p: A => Boolean): Option[A]

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

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

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

Источник

def findLast(p: A => Boolean): Option[A]

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

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

Source

def flatMap[B](f: A => IterableOnce[B]): Buffer[B]

Source

def flatten[B](implicit asIterable: A => IterableOnce[B]): Buffer[B]

Source

def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Source

def foldLeft[B](z: B)(op: (B, A) => B): B

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

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

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

Source

def foldRight[B](z: B)(op: (A, B) => B): B

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

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

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

Source

def forall(p: A => Boolean): Boolean

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

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

Source

def foreach[U](f: A => U): Unit

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

Source

protected def fromSpecific(coll: IterableOnce[A]): Buffer[A]

Source

def groupBy[K](f: A => K): Map[K, Buffer[A]]

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

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

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Source

def groupMap[K, B](key: A => K)(f: A => B): Map[K, Buffer[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором 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)

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

Source

def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B]

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

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

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

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

Source

def grouped(size: Int): Iterator[Buffer[A]]

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

Source

override def hashCode(): Int

Source

def head: A

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

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

Source

def headOption: Option[A]

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

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

Source@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B >: A](elem: B): Int

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

Source

def indexOf[B >: A](elem: B, from: Int): Int

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

Source@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

def indexOfSlice[B >: A](that: Seq[B]): Int

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

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

Source

def indexOfSlice[B >: A](that: Seq[B], from: Int): Int

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

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

Источник@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

def indexWhere(p: A => Boolean): Int

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

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

Источник

def indexWhere(p: A => Boolean, from: Int): Int

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

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

Источник

def indices: Range

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

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

Источник

def init: Buffer[A]

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

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

Источник

def inits: Iterator[Buffer[A]]

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

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

Источник

def intersect[B >: A](that: Seq[B]): Buffer[A]

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

def iterator: Iterator[A]

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

Источник

def last: A

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

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

Источник

def lastIndexOf[B >: A](elem: B, end: Int): Int

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

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

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

def lastIndexOfSlice[B >: A](that: Seq[B]): Int

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

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

Source

def lastIndexOfSlice[B >: A](that: Seq[B], end: Int): Int

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

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

Source@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

def lastIndexWhere(p: A => Boolean): Int

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

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

Source

def lastIndexWhere(p: A => Boolean, end: Int): Int

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

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

Source

def lastOption: Option[A]

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Buffer[A]]

Аналогично 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)

Source

def length: Int

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

Источник

def lengthCompare(that: Iterable[_]): Int

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

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Источник

def lengthCompare(len: Int): Int

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

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Источник@inline

final def lengthIs: SizeCompareOps

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

Эти операции реализуются с помощью 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

Источник

def lift: Int => Option[A]

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

Источник

def map[B](f: A => B): Buffer[B]

Источник

def max[B >: A](implicit ord: Ordering[B]): A

Находит максимальный элемент.

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

Источник

def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A

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

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

Исходный код

def maxByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Исходный код

def maxOption[B >: A](implicit ord: Ordering[B]): Option[A]

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

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

Исходный код

def min[B >: A](implicit ord: Ordering[B]): A

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

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

Исходный код

def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A

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

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

Исходный код

def minByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Исходный код

def minOption[B >: A](implicit ord: Ordering[B]): Option[A]

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

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

Исходный код@inline

final def mkString: String

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

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

Исходный код@inline

final def mkString(sep: String): String

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

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

Исходный код

final def mkString(start: String, sep: String, end: String): String

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

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

Исходный код

protected def newSpecificBuilder: Builder[A, Buffer[A]]

Источник@deprecatedOverriding("nonEmpty определён как !isEmpty; переопределите вместо этого isEmpty", "2.13.0")

def nonEmpty: Boolean

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

Источник

def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Источник

def padTo[B >: A](len: Int, elem: B): Buffer[B]

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

Источник

def partition(p: A => Boolean): (Buffer[A], Buffer[A])

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

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

Источник

def partitionMap[A1, A2](f: A => Either[A1, A2]): (Buffer[A1], Buffer[A2])

Применяет функцию 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))

Источник

def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int): Buffer[B]

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

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

Источник

def permutations: Iterator[Buffer[A]]

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

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

Источник

def prepended[B >: A](elem: B): Buffer[B]

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

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

Пример:

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)

Источник

def prependedAll[B >: A](prefix: IterableOnce[B]): Buffer[B]

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

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

Источник

def product[B >: A](implicit num: Numeric[B]): B

Перемножает элементы этого множества.

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

Source

def reduce[B >: A](op: (B, B) => B): B

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

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

Source

def reduceLeft[B >: A](op: (B, A) => B): B

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

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

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

Source

def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]

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

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

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

Source

def reduceOption[B >: A](op: (B, B) => B): Option[B]

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

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

Source

def reduceRight[B >: A](op: (A, B) => B): B

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

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

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

Source

def reduceRightOption[B >: A](op: (A, B) => B): Option[B]

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

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

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

Source

def reverse: Buffer[A]

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

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

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

Source

def reverseIterator: Iterator[A]

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

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

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

Source

protected def reversed: Iterable[A]

Source

def runWith[U](action: A => U): Int => Boolean

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

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

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

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

Source

def sameElements[B >: A](that: IterableOnce[B]): Boolean

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

Source

def scan[B >: A](z: B)(op: (B, B) => B): Buffer[B]

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

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

Source

def scanLeft[B](z: B)(op: (B, A) => B): Buffer[B]

Source

def scanRight[B](z: B)(op: (A, B) => B): Buffer[B]

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

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

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

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

Пример:

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

Source

def search[B >: A](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

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

Source

def search[B >: A](elem: B)(implicit ord: Ordering[B]): SearchResult

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

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

Source

def segmentLength(p: A => Boolean, from: Int): Int

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

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

Source

final def segmentLength(p: A => Boolean): Int

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

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

Source

final override def size: Int

Source

final override def sizeCompare(that: Iterable[_]): Int

Source

final override def sizeCompare(otherSize: Int): Int

Source@inline

final def sizeIs: SizeCompareOps

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

Эти операции реализованы с использованием 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

Source

def slice(from: Int, until: Int): Buffer[A]

Source

def sliding(size: Int, step: Int): Iterator[Buffer[A]]

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

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

Источник

def sliding(size: Int): Iterator[Buffer[A]]

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

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

Источник

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Buffer[A]

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Источник

def sortWith(lt: (A, A) => Boolean): Buffer[A]

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

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

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

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

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Source

def sorted[B >: A](implicit ord: Ordering[B]): Buffer[A]

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

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

Source

def span(p: A => Boolean): (Buffer[A], Buffer[A])

Source

override def splitAt(n: Int): (Buffer[A], Buffer[A])

Source

def startsWith[B >: A](that: IterableOnce[B], offset: Int): Boolean

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

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

Source

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S

Возвращает scala.collection.Stepper для элементов этой коллекции.

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

Неявный параметр scala.collection.StepperShape определяет тип возвращаемого Stepper в соответствии с типом элемента этой коллекции.

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

• Для любого другого типа элемента возвращается scala.collection.AnyStepper

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

Source

def subtractAll(xs: IterableOnce[A]): Buffer[A]

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

Source

def sum[B >: A](implicit num: Numeric[B]): B

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

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

Source

def tail: Buffer[A]

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

Source

def tails: Iterator[Buffer[A]]

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

Source

def take(n: Int): Buffer[A]

Source

def takeRight(n: Int): Buffer[A]

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

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

Source

def takeWhile(p: A => Boolean): Buffer[A]

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

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

Source

override def tapEach[U](f: A => U): Buffer[A]

Source

def to[C1](factory: Factory[A, C1]): C1

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

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

Source

def toArray[B >: A : ClassTag]: Array[B]

Преобразовать набор в массив.

Примечание: не вызывайте Array.from из этого метода.

Source@inline

final def toBuffer[B >: A]: Buffer[B]

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

def toMap[K, V](implicit ev: A <:< (K, V)): Map[K, V]

Source

def toSeq: Seq[A]

Source

def toSet[B >: A]: Set[B]

Source

override def toString(): String

Source

def toVector: Vector[A]

Source

def transpose[B](implicit asIterable: A => Iterable[B]): Buffer[Buffer[B]]

Транспонирует этот итерируемый набор итерируемых наборов в итерируемый набор итерируемых наборов.

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

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

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

Источник

def unapply(a: Int): Option[A]

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

Источник

def unzip[A1, A2](implicit asPair: A => (A1, A2)): (Buffer[A1], Buffer[A2])

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

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

Источник

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (Buffer[A1], Buffer[A2], Buffer[A3])

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

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

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

def update(idx: Int, elem: A): Unit

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

Источник

def updated[B >: A](index: Int, elem: B): Buffer[B]

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

Источник

override def view: SeqView[A]

Источник

def withFilter(p: A => Boolean): WithFilter[A, Buffer]

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

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

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

Источник

def zip[B](that: IterableOnce[B]): Buffer[(A, B)]

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

Источник

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Buffer[(A1, B)]

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

Source

def zipWithIndex: Buffer[(A, Int)]