Класс ArrayOps.ArrayOps

final class ArrayOps[A](xs: Массив[A]) extends AnyVal

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

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

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

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

Исходный код

final def ++[B >: A : ClassTag](xs: IterableOnce[B]): Массив[B]

Исходный код

final def ++[B >: A : ClassTag](xs: Массив[_ <: B]): Массив[B]

Исходный код

final def ++:[B >: A : ClassTag](prefix: IterableOnce[B]): Массив[B]

Исходный код

final def ++:[B >: A : ClassTag](prefix: Массив[_ <: B]): Массив[B]

Исходный код

final def +:[B >: A : ClassTag](x: B): Массив[B]

Исходный код

final def :+[B >: A : ClassTag](x: B): Массив[B]

Исходный код

final def :++[B >: A : ClassTag](suffix: IterableOnce[B]): Массив[B]

Исходный код

final def :++[B >: A : ClassTag](suffix: Массив[_ <: B]): Массив[B]

Исходный код

def appended[B >: A : ClassTag](x: B): Массив[B]

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

Исходный код

def appendedAll[B >: A : ClassTag](suffix: IterableOnce[B]): Массив[B]

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

Source

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

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

Source

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

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

Source

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

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

Source

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" выбирается. Однако, поскольку все они идентичны, будет выбран только один. Какой из трёх будет выбран — деталь реализации, которая не определена.

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

Source

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

Source

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

Source

def contains(elem: A): Boolean

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

Source

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

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

Source

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

def distinct: Array[A]

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

Источник

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

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

Источник

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

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

Источник

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

Остальная часть массива без его n последних элементов.

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Source

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

Source

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

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

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

Source

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

Source

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

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

Source

def head: A

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

Source

def headOption: Option[A]

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

Source

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

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

Source

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

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

Source

def indices: Range

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

Source

def init: Array[A]

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

Source

def inits: Iterator[Array[A]]

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

Source

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

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

Source

def isEmpty: Boolean

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

Source

def iterator: Iterator[A]

Source

def knownSize: Int

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

Source

def last: A

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

Source

def lastIndexOf(elem: A, end: Int): Int

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

Source

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

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

Source

def lastOption: Option[A]

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

Source

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)

Source

def lengthCompare(len: Int): Int

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

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

Source

def lengthIs: Int

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

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

Source

def map[B](f: A => B)(implicit ct: ClassTag[B]): Array[B]

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

Source

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

Source

def nonEmpty: Boolean

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

Source

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

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

Источник

def partition(p: A => Boolean): (Массив[A], Массив[A])

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

Источник

def partitionMap[A1 : ClassTag, A2 : ClassTag](f: A => Either[A1, A2]): (Массив[A1], Массив[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))

Источник

def patch[B >: A : ClassTag](from: Int, other: IterableOnce[B], replaced: Int): Массив[B]

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

Источник

def permutations: Итератор[Массив[A]]

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

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

Источник

def prepended[B >: A : ClassTag](x: B): Массив[B]

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

Источник

def prependedAll[B >: A : ClassTag](prefix: IterableOnce[B]): Массив[B]

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

Источник

def prependedAll[B >: A : ClassTag](prefix: Массив[_ <: B]): Массив[B]

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

Источник

def reverse: Массив[A]

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

Источник

def reverseIterator: Итератор[A]

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

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

Источник

def scan[B >: A : ClassTag](z: B)(op: (B, B) => B): Массив[B]

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

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

Источник

def scanLeft[B : ClassTag](z: B)(op: (B, A) => B): Массив[B]

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

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

Источник

def scanRight[B : ClassTag](z: B)(op: (A, B) => B): Массив[B]

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

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

Источник

def size: Int

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

Источник

def sizeCompare(otherSize: Int): Int

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

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): Массив[A]

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

from <= indexOf(x) < until

Source

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

Source

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

Source

def tail: Array[A]

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

Source

def tails: Iterator[Array[A]]

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

Source

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

Массив, содержащий первые n элементов этого массива.

Source

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

Массив, содержащий последние n элементы этого массива.

Source

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

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

Source

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

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

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

final def toSeq: Seq[A]

Источник

def transpose[B](implicit asArray: A => Массив[B]): Массив[Массив[B]]

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

Источник

def unzip[A1, A2](implicit asPair: A => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]): (Массив[A1], Массив[A2])

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

Источник

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3), ct1: ClassTag[A1], ct2: ClassTag[A2], ct3: ClassTag[A3]): (Массив[A1], Массив[A2], Массив[A3])

Преобразует массив троек в три массива, по одному массиву на позицию тройки.

Источник

def updated[B >: A : ClassTag](index: Целое, elem: B): Массив[B]

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

Источник

def view: IndexedSeqView[A]

Источник

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

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

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

Источник

def zip[B](that: IterableOnce[B]): Массив[(A, B)]

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

Источник

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Массив[(A1, B)]

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

Источник

def zipWithIndex: Массив[(A, Целое)]

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