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

трейт IndexedBuffer[A] extends IndexedSeq[A] с IndexedSeqOps[A, IndexedBuffer, IndexedBuffer[A]] с Buffer[A] с IterableFactoryDefaults[A, IndexedBuffer]

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

Исходный код

def filterInPlace(p: A => Boolean): IndexedBuffer[A]

Исходный код

def flatMapInPlace(f: A => IterableOnce[A]): IndexedBuffer[A]

Исходный код

override def iterableFactory: SeqFactory[IndexedBuffer]

Исходный код

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Источник@inline

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

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник@inline

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

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

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

Источник@inline

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

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

Источник

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

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

Источник

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

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

Источник@inline

final def addString(b: StringBuilder): 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

Источник@inline

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

Добавляет все элементы этого набора в 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

Источник

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

Добавляет все элементы этого набора в 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)

Источник

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

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

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

Источник

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

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

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

Источник@inline

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

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

Источник@inline

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

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

Источник

def appended[B >: A](elem: B): IndexedBuffer[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]): IndexedBuffer[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

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

Источник

override def clone(): IndexedBuffer[A]

Источник

def collect[B](pf: PartialFunction[A, B]): IndexedBuffer[B]

Источник

def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

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

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

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

Источник

def combinations(n: Int): Iterator[IndexedBuffer[A]]

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

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

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, A]

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

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

Источник@unspecialized

def compose[A](g: A => Int): A => A

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

Источник@inline

final override def concat[B >: A](suffix: IterableOnce[B]): IndexedBuffer[B]

Source

def contains[A1 >: A](elem: A1): Boolean

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

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

Source

def containsSlice[B >: A](that: Seq[B]): Boolean

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

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

Source

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

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

Заполняет заданный массив 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: Array[B], start: Int): Int

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

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

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

Source@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]): IndexedBuffer[A]

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

Источник

def distinct: IndexedBuffer[A]

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

Источник

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

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

Источник

override def drop(n: Int): IndexedBuffer[A]

Источник

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

Источник

override def dropRight(n: Int): IndexedBuffer[A]

Источник

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

Источник

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

Источник

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

Источник

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
}

Источник

override def empty: IndexedBuffer[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): IndexedBuffer[A]

Источник

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

def groupMap[K, B](key: A => K)(f: A => B): Map[K, IndexedBuffer[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)

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

Исходный код

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)(_ + _)

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

Исходный код

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

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

Исходный код

override def hashCode(): Int

Исходный код

override def head: A

Source

override 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

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

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

Source@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

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

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

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

Source

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

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

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

Source

def indices: Range

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

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

Source

def init: IndexedBuffer[A]

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

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

Source

def inits: Iterator[IndexedBuffer[A]]

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

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

Source@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

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

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

Source@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

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

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

Источник

def intersect[B >: A](that: Seq[B]): IndexedBuffer[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]

Источник

override def knownSize: Int

Источник

override def last: A

Источник

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

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

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

Исходный код@deprecatedOverriding("Замените lastIndexOfSlice(that, end) - lastIndexOfSlice(that) вызывает lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код@deprecatedOverriding("Замените lastIndexWhere(p, end) - lastIndexWhere(p) вызывает lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Исходный код

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

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

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

Исходный код

def lastOption: Option[A]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, IndexedBuffer[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)

Источник

def length: Int

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

Источник

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

Источник

final override def lengthCompare(len: Int): Int

Источник@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.

Источник

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

Источник

def mapInPlace(f: A => A): IndexedBuffer[A]

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

Источник

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, IndexedBuffer[A]]

Исходный код@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "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): IndexedBuffer[B]

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

Source

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

Source

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

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

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

Source

def partitionMap[A1, A2](f: A => Either[A1, A2]): (IndexedBuffer[A1], IndexedBuffer[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))

Source

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

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

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

Source

def permutations: Iterator[IndexedBuffer[A]]

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

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

Source

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

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

Source

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

Source

override def prepended[B >: A](elem: B): IndexedBuffer[B]

Source

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

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

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

Source

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник@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

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

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

def remove(idx: Int): A

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

Источник

override def reverse: IndexedBuffer[A]

Источник

override def reverseIterator: Iterator[A]

Источник

override protected def reversed: Iterable[A]

Источник

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

Источник

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

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

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

Пример:

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

final override def size: Int

Источник

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

Источник

final override def sizeCompare(otherSize: Int): Int

Источник@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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): IndexedBuffer[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 sortInPlace[B >: A]()(implicit ord: Ordering[B]): IndexedBuffer[A]

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

Источник

def sortInPlaceBy[B](f: A => B)(implicit ord: Ordering[B]): IndexedBuffer[A]

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

Источник

def sortInPlaceWith(lt: (A, A) => Boolean): IndexedBuffer[A]

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

Исходный код

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

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

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

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

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

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

Источник

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

def tail: IndexedBuffer[A]

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

Источник

def tails: Iterator[IndexedBuffer[A]]

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

Источник

override def take(n: Int): IndexedBuffer[A]

Источник

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

Источник

override def takeRight(n: Int): IndexedBuffer[A]

Источник

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

Источник

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

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

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

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

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

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]): IndexedBuffer[IndexedBuffer[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))

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

Source

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

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

Source

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

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

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

Source

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (IndexedBuffer[A1], IndexedBuffer[A2], IndexedBuffer[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))

Source@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

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

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

Source

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

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

Source

override def view: IndexedSeqView[A]

Source

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

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

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

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

Source

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

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

Source

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

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

Source

def zipWithIndex: IndexedBuffer[(A, Int)]