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

@SerialVersionUID(3L)

final class ofRef[T <: AnyRef](val array: Array[T]) extends ArraySeq[T]

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

Исходный код

def apply(index: Int): T

Исходный код

def elemTag: ClassTag[_]

Исходный код

override def equals(that: Any): Boolean

Исходный код

override def hashCode: Int

Исходный код

override def iterator: Iterator[T]

Исходный код

def length: Int

Исходный код

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

Исходный код

def update(index: Int, elem: T): Unit

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

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

final def ++[B >: T](suffix: IterableOnce[B]): ArraySeq[B]

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

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

final override def ++:[B >: T](prefix: IterableOnce[B]): ArraySeq[B]

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

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

final def +:[B >: T](elem: B): ArraySeq[B]

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

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

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

final def :+[B >: T](elem: B): ArraySeq[B]

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

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

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

final def :++[B >: T](suffix: IterableOnce[B]): ArraySeq[B]

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

Исходный код@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

Исходный код@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

Исходный код

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)

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

override def appended[B >: T](elem: B): ArraySeq[B]

Исходный код

override def appendedAll[B >: T](suffix: IterableOnce[B]): ArraySeq[B]

Источник

def applyOrElse[A1 <: Int, B1 >: T](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

Источник

override def clone(): ArraySeq[T]

Клонирует этот объект, включая базовый массив.

Источник

override def collect[B](pf: PartialFunction[T, B]): ArraySeq[B]

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[ArraySeq[T]]

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

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

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

Источник

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

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

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

Источник@unspecialized

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

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

Источник@inline

final override def concat[B >: T](suffix: IterableOnce[B]): ArraySeq[B]

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

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

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

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

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

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

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

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

Источник

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

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

override def diff[B >: T](that: Seq[B]): ArraySeq[T]

Исходный код

def distinct: ArraySeq[T]

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

Исходный код

override def distinctBy[B](f: T => B): ArraySeq[T]

Исходный код

override def drop(n: Int): ArraySeq[T]

Исходный код

override def dropRight(n: Int): ArraySeq[T]

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

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

Исходный код

def dropWhile(p: T => Boolean): ArraySeq[T]

Исходный код

def elementWise: ElementWiseExtractor[Int, T]

Возвращает объект-экстрактор с методом 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: ArraySeq[T]

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

override def filter(pred: T => Boolean): ArraySeq[T]

Исходный код

override def filterNot(pred: T => Boolean): ArraySeq[T]

Source

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

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

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

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

Source

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

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

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

Source

override def flatMap[B](f: T => IterableOnce[B]): ArraySeq[B]

Source

override def flatten[B](implicit toIterableOnce: T => IterableOnce[B]): ArraySeq[B]

Source

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

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

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

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

Source

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

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

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

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

Источник

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

Источник

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

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

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

Источник

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

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

Источник

def groupBy[K](f: T => K): Map[K, ArraySeq[T]]

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

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

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

Источник

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

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

Source

override def head: T

Source

override def headOption: Option[T]

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

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

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

Source

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: ArraySeq[T]

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

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

Источник

def inits: Iterator[ArraySeq[T]]

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

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

Источник

override def intersect[B >: T](that: Seq[B]): ArraySeq[T]

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: SeqFactory[ArraySeq]

Источник

override def knownSize: Int

Источник

override def last: T

Источник

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

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def lastOption: Option[T]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[T, B, ofRef[T]]

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

Источник

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[T]

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

Источник

override def map[B](f: T => B): ArraySeq[B]

Источник

def mapInPlace(f: T => T): ofRef[T]

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код@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, который может быть переопределён.

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Источник

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

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

Источник

override def padTo[B >: T](len: Int, elem: B): ArraySeq[B]

Источник

override def partition(p: T => Boolean): (ArraySeq[T], ArraySeq[T])

Source

override def partitionMap[A1, A2](f: T => Either[A1, A2]): (ArraySeq[A1], ArraySeq[A2])

Source

def patch[B >: T](from: Int, other: IterableOnce[B], replaced: Int): ArraySeq[B]

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

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

Source

def permutations: Iterator[ArraySeq[T]]

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

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

Source

override def prepended[B >: T](elem: B): ArraySeq[B]

Source

override def prependedAll[B >: T](prefix: IterableOnce[B]): ArraySeq[B]

Source

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Источник

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

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

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

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

Источник

override def reverse: ArraySeq[T]

Источник

override def reverseIterator: Iterator[T]

Источник

override protected def reversed: Iterable[T]

Источник

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

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

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

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

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

Источник

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

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

Источник

def scan[B >: T](z: B)(op: (B, B) => B): ArraySeq[B]

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

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

Источник

override def scanLeft[B](z: B)(op: (B, T) => B): ArraySeq[B]

Источник

def scanRight[B](z: B)(op: (T, B) => B): ArraySeq[B]

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

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

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

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

Пример:

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

Источник

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

Источник

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

Источник

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

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

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

Source

final def segmentLength(p: T => 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

override def slice(from: Int, until: Int): ArraySeq[T]

Source

def sliding(size: Int, step: Int): Iterator[ArraySeq[T]]

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

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

Source

def sliding(size: Int): Iterator[ArraySeq[T]]

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

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

Source

def sortBy[B](f: T => B)(implicit ord: Ordering[B]): ArraySeq[T]

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

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

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

Сортировка стабильна. То есть, элементы, которые равны (как определено в 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)

Source

override def sortInPlace[B >: T]()(implicit ord: Ordering[B]): ofRef[T]

Source

def sortInPlaceBy[B](f: T => B)(implicit ord: Ordering[B]): ofRef[T]

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

Source

def sortInPlaceWith(lt: (T, T) => Boolean): ofRef[T]

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

Source

def sortWith(lt: (T, T) => Boolean): ArraySeq[T]

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

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

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

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

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

Source

override def sorted[B >: T](implicit ord: Ordering[B]): ArraySeq[T]

Source

override def span(p: T => Boolean): (ArraySeq[T], ArraySeq[T])

Source

override def splitAt(n: Int): (ArraySeq[T], ArraySeq[T])

Source

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

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

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

Source

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

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

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

Source

def tail: ArraySeq[T]

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

Source

def tails: Iterator[ArraySeq[T]]

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

Source

override def take(n: Int): ArraySeq[T]

Source

override def takeRight(n: Int): ArraySeq[T]

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

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

Source

def takeWhile(p: T => Boolean): ArraySeq[T]

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

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

Source

override def tapEach[U](f: T => U): ArraySeq[T]

Source

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

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

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

Source

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

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

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[T]

Source

def toList: List[T]

Source

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

Source

def toSeq: Seq[T]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[T]

Source

def transpose[B](implicit asIterable: T => Iterable[B]): ArraySeq[ArraySeq[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[T]

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

Source

override def unzip[A1, A2](implicit asPair: T => (A1, A2)): (ArraySeq[A1], ArraySeq[A2])

Source

override def unzip3[A1, A2, A3](implicit asTriple: T => (A1, A2, A3)): (ArraySeq[A1], ArraySeq[A2], ArraySeq[A3])

Source

def updated[B >: T](index: Int, elem: B): ArraySeq[B]

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

Source

override def view: IndexedSeqView[T]

Source

def withFilter(p: T => Boolean): WithFilter[T, ArraySeq]

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

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

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

Source

override def zip[B](that: IterableOnce[B]): ArraySeq[(T, B)]

Source

def zipAll[A1 >: T, B](that: Iterable[B], thisElem: A1, thatElem: B): ArraySeq[(A1, B)]

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

Source

override def zipWithIndex: ArraySeq[(T, Int)]

Конкретные поля

Source

val array: Array[T]