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

@SerialVersionUID(3L)

final class ofShort(val array: Массив[Short]) extends ArraySeq[Short]

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

Исходный код

def apply(index: Int): Short

Исходный код

def elemTag: ClassTag[_]

Исходный код

override def equals(that: Any): Boolean

Исходный код

override def hashCode: Int

Исходный код

override def iterator: Итератор[Short]

Исходный код

def length: Int

Исходный код

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

Исходный код

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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[Short, C]): PartialFunction[Int, C]

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

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

Source

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

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

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

Источник

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

Источник

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

Источник

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

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

Источник

override def collect[B](pf: ЧастичнаяФункция[Short, B]): ArraySeq[B]

Источник

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

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

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

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

Источник

def combinations(n: Int): Итератор[ArraySeq[Short]]

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

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

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

Источник

def compose[R](k: ЧастичнаяФункция[R, Int]): ЧастичнаяФункция[R, Short]

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

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

Источник@unspecialized

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

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

Источник@inline

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

Источник

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

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

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

Источник

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

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

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

Источник

override def copyToArray[B >: Short](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 >: Short](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 >: Short](xs: Array[B]): Int

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

Source

def distinct: ArraySeq[Short]

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

Источник

def elementWise: ElementWiseExtractor[Int, Short]

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

Источник

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

Source

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

Source

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

Source

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

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

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

Source

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

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

Source

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

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

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

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

Source

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

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

Source

override def head: Short

Source

override def headOption: Option[Short]

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

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

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

Source

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

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

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

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

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

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

Source

def indexOfSlice[B >: Short](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: Short => Boolean): Int

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: ArraySeq[Short]

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

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

Источник

def inits: Iterator[ArraySeq[Short]]

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

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

Источник

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

Источник

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: Short

Источник

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

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Исходный код

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

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

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

Исходный код

def lastOption: Option[Short]

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

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

Исходный код

def lazyZip[B](that: Iterable[B]): LazyZip2[Short, B, ofShort]

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

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

Исходный код

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

Исходный код

def mapInPlace(f: Short => Short): ofShort

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

Исходный код

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

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

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

Исходный код

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

Проверяет, не является ли коллекция пустой.

Source

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

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

Source

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

Source

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

Source

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

Source

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

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

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

Source

def permutations: Iterator[ArraySeq[Short]]

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

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

Source

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

Source

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

override def reverse: ArraySeq[Short]

Источник

override def reverseIterator: Iterator[Short]

Источник

override protected def reversed: Iterable[Short]

Источник

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

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

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

Source

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

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

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

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

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

Пример:

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

Source

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

Source

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

Source

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

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

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

Source

final def segmentLength(p: Short => 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[Short]

Source

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

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

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

Source

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

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

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

Источник

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

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

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

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

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

Источник

override def sortInPlace[B >: Short]()(implicit ord: Ordering[B]): ofShort

Источник

def sortInPlaceBy[B](f: Short => B)(implicit ord: Ordering[B]): ofShort

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

Источник

def sortInPlaceWith(lt: (Short, Short) => Boolean): ofShort

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

Источник

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

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

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

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

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

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

Источник

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

def tail: ArraySeq[Short]

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

Источник

def tails: Итератор[ArraySeq[Short]]

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

Источник

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

Преобразование коллекции в массив.

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

Источник@inline

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

Источник

def toIndexedSeq: IndexedSeq[Short]

Источник

def toList: List[Short]

Источник

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

Источник

def toSeq: Seq[Short]

Источник

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

Источник

override def toString(): String

Источник

def toVector: Vector[Short]

Источник

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

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

Источник

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

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

Исходный код

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

Исходный код

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

Исходный код

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

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

Исходный код

override def view: IndexedSeqView[Short]

Исходный код

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

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

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

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

Исходный код

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

Исходный код

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

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

Исходный код

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

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

Исходный код

val array: Array[Short]