Класс scala.collection.ArrayOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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]

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

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

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

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

Исходный код

def contains(elem: A): Boolean

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

Исходный код

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

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

Исходный код

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(@deprecatedName("f", "2.13.3") p: A => Boolean): Boolean

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

Исходный код

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

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

Исходный код

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

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

Исходный код

def find(@deprecatedName("f", "2.13.3") p: A => Boolean): Option[A]

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

Source

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(@deprecatedName("f", "2.13.3") 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

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

Источник

def indexWhere(@deprecatedName("f", "2.13.3") p: A => Boolean, from: Int): Int

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

Источник

def indices: Range

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

Источник

def init: Array[A]

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

Источник

def inits: Iterator[Array[A]]

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

Источник

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

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

Источник@inline

def isEmpty: Boolean

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

Источник

def iterator: Iterator[A]

Источник@inline

def knownSize: Int

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

Источник

def last: A

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

Источник

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

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

Источник

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

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

Источник

def lastOption: Option[A]

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

Источник

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)

Источник

def lengthCompare(len: Int): Int

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

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]

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

Источник

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

Source@inline

def nonEmpty: Boolean

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

Source

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

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

Source

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

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

Source

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

Source

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

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

Source

def permutations: Iterator[Array[A]]

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

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

Source

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

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

Source

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

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

Source

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

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

Source@inline

def reverse: Array[A]

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

Source

def reverseIterator: Iterator[A]

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source@inline

def size: Int

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

Source

def sizeCompare(otherSize: Int): Int

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

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

Source

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

Source

def slice(from: Int, until: Int): Array[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@inline

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]

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

Source

def toIndexedSeq: IndexedSeq[A]

Source@inline

final def toSeq: Seq[A]

Source

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

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

Source

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

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

Source

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])

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

Source

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

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

Source@inline

def view: IndexedSeqView[A]

Source

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

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

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

Source

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

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

Source

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

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

Source

def zipWithIndex: Array[(A, Int)]

Сжимает этот массив со своими индексами.