Класс scala.collection.ArrayOps

Компаньон объект ArrayOps

final класс ArrayOps[A] extends AnyVal

Этот класс служит оболочкой для Arrays с множеством операций, найденных в индексированных последовательностях. По мере необходимости экземпляры массивов неявно преобразуются в этот класс. В общем случае нет необходимости явно создавать экземпляр или использовать тип ArrayOps. Лучше работать с обычными Array типами и полагаться на неявное преобразование в ArrayOps при вызове метода (который фактически не выделяет экземпляр ArrayOps из-за того, что это класс-значение).

Ни Array , ни ArrayOps не являются правильными типами коллекций (т.е. они не наследуют Iterable или даже IterableOnce). mutable.ArraySeq и immutable.ArraySeq служат этой цели.

Разница между этим классом и ArraySeqs заключается в том, что вызов методов преобразования, таких как filter и map, приведет к массиву, в то время как ArraySeq останется ArraySeq.

A: тип элементов, содержащихся в этом массиве.

Source: ArrayOps.scala
Since: 2.8
Линейные надтипы: AnyVal, Any

Конструкторы экземпляров

новый ArrayOps(xs: Массив[A])

Члены значения

окончательный def !=(arg0: Любой): Булево

Проверка двух объектов на неравенство.

возвращает: true если !(this == that), в противном случае false.

Определяющие классы: Любой

окончательный def ##(): Целое число

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

возвращает: значение хэша, согласованное с ==

Определяющие классы: Любой

def +(other: Строка): Строка

Неявный: Этот член добавлен неявным преобразованием из ArrayOps[A] вany2stringadd[ArrayOps[A]] посредством метода any2stringadd в scala.Predef.
Определяющие классы: any2stringadd

окончательный def ++[B >: A](xs: Массив[_ <: B])(неявный arg0: ClassTag[B]): Массив[B]

Аннотации: @inline()

окончательный def ++[B >: A](xs: IterableOnce[B])(неявный arg0: ClassTag[B]): Массив[B]

Аннотации: @inline()

окончательный def ++:[B >: A](prefix: Массив[_ <: B])(неявный arg0: ClassTag[B]): Массив[B]

Аннотации: @inline()

окончательный def ++:[B >: A](prefix: IterableOnce[B])(неявный arg0: ClassTag[B]): Массив[B]

Аннотации: @inline()

окончательный def +:[B >: A](x: B)(неявный arg0: ClassTag[B]): Массив[B]

Аннотации: @inline()

def ->[B](y: B): (ArrayOps[A], B)

Неявный: Этот член добавлен неявным преобразованием из ArrayOps[A] вArrowAssoc[ArrayOps[A]] посредством метода ArrowAssoc в scala.Predef.
Определяющие классы: ArrowAssoc
Аннотации: @inline()

final def :+[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]

Annotations: @inline()

final def :++[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]

Annotations: @inline()

final def :++[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]

Annotations: @inline()

final def ==(arg0: Any): Boolean

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

возвращает: true если объект-получатель эквивалентен аргументу; false в противном случае.

Definition Classes: Any

def appended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]

def appendedAll[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]

def appendedAll[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]

final def asInstanceOf[T0]: T0

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

Обратите внимание, что успех приведения во время выполнения зависит от семантики стирания Scala. Поэтому выражение 1.asInstanceOf[String] вызовет ClassCastException во время выполнения, а выражение List(1).asInstanceOf[List[String]] — нет. В последнем примере, из-за стирания типа аргумента во время компиляции невозможно проверить, содержат ли элементы списка требуемый тип.

возвращает: объект-получатель.

Definition Classes: Any
Исключения: ClassCastException, если объект-получатель не является экземпляром стирания типа T0.

def collect[B](pf: PartialFunction[A, B])(implicit arg0: ClassTag[B]): Array[B]

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

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

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

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

Перебирает комбинации. _Комбинация_ длины n — это подпоследовательность исходного массива, элементы которой взяты по порядку. Таким образом, Array("x", "y") и Array("y", "y") — это комбинации длины 2 из Array("x", "y", "y"), но Array("y", "x") — нет. Если существует несколько способов сгенерировать одну и ту же подпоследовательность, будет возвращен только один из них.

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

returns: Итератор, который проходит по возможным n-элементным комбинациям этого массива.

Example:

Array("a", "b", "b", "b", "c").combinations(2) == Iterator(Array(a, b), Array(a, c), Array(b, b), Array(b, c))

final def concat[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]

Annotations: @inline()

final def concat[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]

Annotations: @inline()

def contains(elem: A): Boolean

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

elem: элемент для проверки.
returns: true если этот массив имеет элемент, равный (как определено ==) elem, false в противном случае.

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

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

B: тип элементов массива.
xs: массив для заполнения.
start: начальный индекс в целевом массиве.
len: максимальное количество элементов для копирования.

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

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

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

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

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

B: тип элементов массива.
xs: массив для заполнения.

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

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

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

that: последовательность элементов для удаления
returns: новый массив, который содержит все элементы этого массива, за исключением некоторых вхождений элементов, которые также встречаются в that. Если значение элемента x встречается n раз в that, то первые n вхождений x не будут входить в результат, но любые последующие вхождения будут.

def distinct: Array[A]

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

returns: новый массив, состоящий из всех элементов этого массива без дубликатов.

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

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

B: тип элементов после преобразования функцией f
f: Функция преобразования, результат которой используется для определения уникальности каждого элемента
returns: новый массив, состоящий из всех элементов этого массива без дубликатов.

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

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

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

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

p: Предикат для проверки элементов.
returns: самый длинный суффикс этого массива, первый элемент которого не удовлетворяет предикату p.

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

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

that: последовательность для проверки
returns: true если этот массив имеет that в качестве суффикса, false в противном случае.

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

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

that: массив для проверки
returns: true если этот массив имеет that в качестве суффикса, false в противном случае.

def ensuring(cond: (ArrayOps[A]) => Boolean, msg: => Any): ArrayOps[A]

Неявный: Этот член добавлен неявным преобразованием из ArrayOps[A] вEnsuring[ArrayOps[A]] с помощью метода Ensuring в scala.Predef.
Определяющие классы: Ensuring

def ensuring(cond: (ArrayOps[A]) => Boolean): ArrayOps[A]

Неявный: Этот член добавлен неявным преобразованием из ArrayOps[A] вEnsuring[ArrayOps[A]] с помощью метода Ensuring в scala.Predef.
Определяющие классы: Ensuring

def ensuring(cond: Boolean, msg: => Any): ArrayOps[A]

Неявный: Этот член добавлен неявным преобразованием из ArrayOps[A] вEnsuring[ArrayOps[A]] с помощью метода Ensuring в scala.Predef.
Определяющие классы: Ensuring

def ensuring(cond: Boolean): ArrayOps[A]

Неявный: Этот член добавлен неявным преобразованием из ArrayOps[A] вEnsuring[ArrayOps[A]] с помощью метода Ensuring в scala.Predef.
Определяющие классы: Ensuring

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

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

returns: true если заданный предикат p удовлетворяется хотя бы одним элементом этого массива, в противном случае false

def filter(p: (A) => Boolean): Array[A]

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

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

def filterNot(p: (A) => Boolean): Array[A]

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

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

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

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

returns: значение Option, содержащее первый элемент в массиве, удовлетворяющий p, или None , если такового нет.

def flatMap[BS, B](f: (A) => BS)(implicit asIterable: (BS) => Iterable[B], m: ClassTag[B]): Array[B]

def flatMap[B](f: (A) => IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]

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

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

def flatten[B](implicit asIterable: (A) => IterableOnce[B], m: ClassTag[B]): Array[B]

Разворачивает двумерный массив, конкатенируя все его строки в один массив.

B: Тип элементов строки.
asIterable: Функция, преобразующая элементы этого массива в строки - итераторы типа B.
returns: Массив, полученный путем конкатенации строк этого массива.

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

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

A1: параметр типа для бинарного оператора, надтипом A.
z: нейтральный элемент для операции fold; может быть добавлен к результату произвольное количество раз, и не должен изменять результат (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения).
op: бинарный оператор, который должен быть ассоциативным.
returns: результат применения оператора fold op между всеми элементами или z если этот массив пуст.

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

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого массива слева направо с начальным значением z слева:

op(...op(z, x_1), x_2, ..., x_n)

где x₁, ..., x_n — элементы этого массива. Возвращает z если этот массив пуст.

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

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого массива, справа налево, с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n - элементы этого массива. Возвращает z если этот массив пуст.

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

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

returns: true если этот массив пуст или заданный предикат p выполняется для всех элементов этого массива, иначе false.

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

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

def formatted(fmtstr: String): String

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

Implicit: Этот член добавляется неявным преобразованием из ArrayOps[A] в StringFormat[ArrayOps[A]] выполняемым методом StringFormat в scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

def getClass(): Class[_ <: AnyVal]

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

returns: объект класса, соответствующий типу получателя во время выполнения.

Definition Classes: AnyVal → Any

def groupBy[K](f: (A) => K): immutable.Map[K, Array[A]]

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

K

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

f

функция дискриминатора.

returns

Карта из ключей в массивы, такая что выполняется следующее инвариантное условие:

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

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

def groupMap[K, B](key: (A) => K)(f: (A) => B)(implicit arg0: ClassTag[B]): immutable.Map[K, Array[B]]

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

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

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

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

K: тип ключей, возвращаемых функцией дискриминатора
B: тип значений, возвращаемых функцией преобразования
key: функция дискриминатора
f: функция преобразования элементов

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

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

size: количество элементов в группе
returns: Итератор, создающий массивы размером size, за исключением последнего, который будет меньше размера size, если элементы не делятся равномерно.

See also: scala.collection.Iterator, метод grouped

def head: A

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

returns: первый элемент этого массива.

Exceptions thrown: NoSuchElementException если массив пуст.

def headOption: Option[A]

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

returns: первый элемент массива, если он не пустой, None если массив пустой.

def indexOf(elem: A, from: Int = 0): Int

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

elem: значение искомого элемента.
from: начальный индекс
returns: индекс >= from первого элемента массива, который равен (как определяется ==) elem, или -1, если такого элемента нет.

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

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

from: начальный индекс
returns: индекс >= from первого элемента массива, удовлетворяющего предикату p, или -1, если такого элемента нет.

def indices: immutable.Range

Возвращает диапазон всех индексов в последовательности.

returns: значение Range от 0 до значения на единицу меньше длины массива.

def init: Array[A]

def inits: Iterator[Array[A]]

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

returns: итератор по всем начальным сегментам массива

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

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

that: последовательность элементов для пересечения.
returns: новый массив, содержащий все элементы этого массива, которые также присутствуют в that. Если значение элемента x встречается n раз в that, то первые n вхождений x будут сохранены в результате, но любые последующие вхождения будут опущены.

def isEmpty: Boolean

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

returns: true если массив не содержит элементов, false в противном случае.

Annotations: @inline()

final def isInstanceOf[T0]: Boolean

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

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

returns: true если объект приемник является экземпляром стираемого типа T0; false в противном случае.

Definition Classes: Any

def iterator: Iterator[A]

def knownSize: Int

Размер этого массива.

returns: количество элементов в этом массиве.

Annotations: @inline()

def last: A

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

returns: Последний элемент этого массива.

Exceptions thrown: NoSuchElementException Если массив пуст.

def lastIndexOf(elem: A, end: Int = xs.length - 1): Int

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

elem: значение искомого элемента.
end: конечный индекс.
returns: индекс <= end последнего элемента этого массива, который равен (как определяется ==) elem, или -1, если такого элемента нет.

def lastIndexWhere(p: (A) => Boolean, end: Int = xs.length - 1): Int

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

p: предикат, используемый для проверки элементов.
возвращает: индекс <= end последнего элемента этого массива, удовлетворяющего предикату p, или -1, если такового нет.

def lastOption: Option[A]

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

возвращает: последний элемент этого массива, если он непустой, None если он пустой.

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

B: тип второго элемента в каждой потенциальной паре
that: iterable, предоставляющий второй элемент каждой потенциальной пары
возвращает: декоратор LazyZip2, который позволяет выполнять строгие операции над лениво вычисляемыми парами или цепочкой вызовов lazyZip. Также поддерживается неявное преобразование в Iterable[(A, B)].

def lengthCompare(len: Int): Int

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

len

значение теста, которое сравнивается с длиной.

возвращает

Значение x, где

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

def lengthIs: Int

Метод, отражающий SeqOps.lengthIs для согласованности, за исключением того, что он возвращает Int, потому что length известно, и сравнение выполняется за постоянное время.

Эти операции эквивалентны 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 map[B](f: (A) => B)(implicit ct: ClassTag[B]): Array[B]

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

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

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

def nonEmpty: Boolean

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

возвращает: true, если массив содержит по крайней мере один элемент, false в противном случае.

Annotations: @inline()

def padTo[B >: A](len: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]

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

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

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

def partitionMap[A1, A2](f: (A) => Either[A1, A2])(implicit arg0: ClassTag[A1], arg1: ClassTag[A2]): (Array[A1], Array[A2])

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

Пример:

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

A1: тип элементов первого результирующего набора
A2: тип элементов второго результирующего набора
f: функция 'разделения', отображающая элементы этого массива в scala.util.Either
returns: пара массивов: первый содержит значения, возвращённые f, которые были обернуты в scala.util.Left, а второй — значения, обернутые в scala.util.Right.

def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int)(implicit arg0: ClassTag[B]): Array[B]

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

from: Начальный индекс для замены
other: Значения для замены
replaced: Количество значений в исходном массиве, заменяемых вставкой.

def permutations: Iterator[Array[A]]

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

returns: Итератор, проходящий по различным перестановкам этого массива.

Пример:

Array("a", "b", "b").permutations == Iterator(Array(a, b, b), Array(b, a, b), Array(b, b, a))

def prepended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]

def prependedAll[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]

def prependedAll[B >: A](prefix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]

def reverse: Array[A]

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

Annotations: @inline()

def reverseIterator: Iterator[A]

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

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

returns: итератор, возвращающий элементы этого массива в обратном порядке

def scan[B >: A](z: B)(op: (B, B) => B)(implicit arg0: ClassTag[B]): Array[B]

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

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

B: тип элементов результирующего массива
z: нейтральный элемент для оператора op
op: ассоциативный оператор для сканирования
returns: новый массив, содержащий префиксное сканирование элементов в этом массиве

def scanLeft[B](z: B)(op: (B, A) => B)(implicit arg0: ClassTag[B]): Array[B]

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

массив с промежуточными значениями. Пример:

Array(1, 2, 3, 4).scanLeft(0)(_ + _) == Array(0, 1, 3, 6, 10)

def scanRight[B](z: B)(op: (A, B) => B)(implicit arg0: ClassTag[B]): Array[B]

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

массив с промежуточными значениями. Пример:

Array(4, 3, 2, 1).scanRight(0)(_ + _) == Array(10, 6, 3, 1, 0)

def size: Int

Размер этого массива.

returns: количество элементов в этом массиве.

Annotations: @inline()

def sizeCompare(otherSize: Int): Int

Сравнивает размер этого массива со значением.

otherSize

значение для сравнения с размером.

returns

Значение x, где

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

def sizeIs: Int

Метод, дублирующий SeqOps.sizeIs для согласованности, но возвращает Int, так как size известно и сравнение выполняется за постоянное время.

Эти операции эквивалентны 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

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

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

from <= indexOf(x) < until

from: наименьший индекс для включения из этого массива.
until: наименьший индекс для ИСКЛЮЧЕНИЯ из этого массива.
returns: массив, содержащий элементы, большие или равные индексу from, до (но не включая) индекса until этого массива.

def sliding(size: Int, step: Int = 1): Iterator[Array[A]]

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

size: количество элементов в группе
step: расстояние между первыми элементами последовательных групп
returns: Итератор, производящий массивы размера size, за исключением последнего элемента (который может быть единственным), который будет усечён, если оставшихся элементов для группировки меньше, чем size.

See also: scala.collection.Iterator, метод sliding

def sortBy[B](f: (A) => B)(implicit ord: math.Ordering[B]): Array[A]

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

B: целевой тип преобразования f, и тип, где определён порядок ord.
f: функция преобразования, отображающая элементы в другую область B.
ord: порядок, предполагаемый в области B.
returns: массив, состоящий из элементов этого массива, отсортированных согласно порядку, где x < y, если ord.lt(f(x), f(y)).

See also: scala.math.Ordering

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

Сортирует этот массив согласно функции сравнения.

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

lt: функция сравнения, проверяющая, предшествует ли первый аргумент второму аргументу в желаемом порядке.
returns: массив, состоящий из элементов этого массива, отсортированных согласно функции сравнения lt.

def sorted[B >: A](implicit ord: math.Ordering[B]): Array[A]

Сортирует этот массив в соответствии с Ordering.

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

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

См. также: scala.math.Ordering

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

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

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

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

def splitAt(n: Int): (Array[A], Array[A])

Разделяет этот массив на две части в заданной позиции. Примечание: c splitAt n эквивалентно (c take n, c drop n).

n: позиция разделения.
returns: пара массивов, состоящая из первых n элементов этого массива и других элементов.

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

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

that: последовательность для проверки
offset: индекс, где ищется последовательность.
returns: true, если последовательность that содержится в этом массиве по индексу offset, в противном случае false.

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

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

that: массив для проверки
offset: индекс, где ищется массив.
returns: true если массив that содержится в этом массиве по индексу offset, в противном случае false.

def startsWith[B >: A](that: Array[B]): Boolean

Проверяет, начинается ли этот массив с заданного массива.

Аннотации: @inline()

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

def tail: Array[A]

def tails: Iterator[Array[A]]

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

returns: итератор по всем хвостам этого массива

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

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

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

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

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

def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

def toIndexedSeq: immutable.IndexedSeq[A]

final def toSeq: immutable.Seq[A]

Annotations: @inline()

def toString(): String

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

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

returns: строковое представление объекта.

Определяющие классы: Any

def transpose[B](implicit asArray: (A) => Array[B]): Array[Array[B]]

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

B: Тип элементов строки.
asArray: Функция, которая преобразует элементы этого массива в строки - массивы типа B.
returns: Массив, полученный путем замены элементов этого массива на строки, которые они представляют.

def unzip[A1, A2](implicit asPair: (A) => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]): (Array[A1], Array[A2])

Преобразует массив пар в массив первых элементов и массив вторых элементов.

A1: тип первой половины пар элементов
A2: тип второй половины пар элементов
asPair: неявное преобразование, которое утверждает, что тип элемента этого массива является парой.
ct1: тег класса для параметра типа A1, который необходим для создания экземпляра Array[A1]
ct2: тег класса для параметра типа A2, который необходим для создания экземпляра Array[A2]
returns: пара массивов, содержащих соответственно первую и вторую половину каждой пары элементов этого массива.

def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3), ct1: ClassTag[A1], ct2: ClassTag[A2], ct3: ClassTag[A3]): (Array[A1], Array[A2], Array[A3])

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

A1: тип первого из трех элементов в тройке
A2: тип второго из трех элементов в тройке
A3: тип третьего из трех элементов в тройке
asTriple: неявное преобразование, которое утверждает, что тип элемента этого массива является тройкой.
ct1: тег класса для параметра типа T1, который необходим для создания экземпляра Array[T1]
ct2: тег класса для параметра типа T2, который необходим для создания экземпляра Array[T2]
ct3: тег класса для параметра типа T3, который необходим для создания экземпляра Array[T3]
returns: тройка массивов, содержащих соответственно первый, второй и третий элементы из каждой тройки элементов этого массива.

def updated[B >: A](index: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]

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

index: позиция замены
elem: заменяющий элемент
returns: новый массив, который является копией этого массива с элементом в позиции index замененным на elem.

Выбрасываемые исключения: IndexOutOfBoundsException если index не удовлетворяет 0 <= index < length.

def view: IndexedSeqView[A]

Annotations: @inline()

def withFilter(p: (A) => Boolean): ArrayOps.WithFilter[A]

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

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

p: предикат, используемый для проверки элементов.
возвращает: объект класса ArrayOps.WithFilter, который поддерживает map, flatMap, foreach, и withFilter операции. Все эти операции применяются к тем элементам этого массива, которые удовлетворяют предикату p.

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

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

B: тип второй половины возвращаемых пар
that: Итерируемая коллекция, предоставляющая вторую половину каждой пары результата
возвращает: новый массив, содержащий пары, состоящие из соответствующих элементов этого массива и that. Длина возвращаемого массива является минимальной из длин этого массива и that.

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

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

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

def zipWithIndex: Array[(A, Int)]

Объединяет этот массив с его индексами.

возвращает: новый массив, содержащий пары, состоящие из всех элементов этого массива, соединённых со своими индексами. Индексы начинаются с 0.

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.13.0/scala/collection/ArrayOps.html