Class ArrayOps.ArrayOps

final class ArrayOps[A](xs: Array[A]) extends AnyVal

This class serves as a wrapper for Arrays with many of the operations found in indexed sequences. Where needed, instances of arrays are implicitly converted into this class. There is generally no reason to create an instance explicitly or use an ArrayOps type. It is better to work with plain Array types instead and rely on the implicit conversion to ArrayOps when calling a method (which does not actually allocate an instance of ArrayOps because it is a value class).

Neither Array nor ArrayOps are proper collection types (i.e. they do not extend Iterable or even IterableOnce). mutable.ArraySeq and immutable.ArraySeq serve this purpose.

The difference between this class and ArraySeqs is that calling transformer methods such as filter and map will yield an array, whereas an ArraySeq will remain an ArraySeq.

Concrete methods

Source

final def ++[B >: A : ClassTag](xs: IterableOnce[B]): Array[B]

Source

final def ++[B >: A : ClassTag](xs: Array[_ <: B]): Array[B]

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

A copy of this array with an element appended.

Source

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

A copy of this array with all elements of a collection appended.

Source

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

A copy of this array with all elements of an array appended.

Source

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

Builds a new array by applying a partial function to all elements of this array on which the function is defined.

Source

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

Finds the first element of the array for which the given partial function is defined, and applies the partial function to it.

Source

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

Iterates over combinations. A _combination_ of length n is a subsequence of the original array, with the elements taken in order. Thus, Array("x", "y") and Array("y", "y") are both length-2 combinations of Array("x", "y", "y"), but Array("y", "x") is not. If there is more than one way to generate the same subsequence, only one will be returned.

For example, Array("x", "y", "y", "y") has three different ways to generate Array("x", "y") depending on whether the first, second, or third "y" is selected. However, since all are identical, only one will be chosen. Which of the three will be taken is an implementation detail that is not defined.

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

Tests whether this array contains a given value as an element.

Source

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

Copy elements of this array to another array. Fills the given array xs starting at index 0. Copying will stop once either all the elements of this array have been copied, or the end of the array is reached.

Source

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

Copy elements of this array to another array. Fills the given array xs starting at index start. Copying will stop once either all the elements of this array have been copied, or the end of the array is reached.

Source

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

Copy elements of this array to another array. Fills the given array xs starting at index start with at most len values. Copying will stop once either all the elements of this array have been copied, or the end of the array is reached, or len elements have been copied.

Source

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

Counts the number of elements in this array which satisfy a predicate

Source

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

Computes the multiset difference between this array and another sequence.

Source

def distinct: Array[A]

Selects all the elements of this array ignoring the duplicates.

Source

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

Selects all the elements of this array ignoring the duplicates as determined by == after applying the transforming function f.

Source

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

The rest of the array without its n first elements.

Source

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

The rest of the array without its n last elements.

Source

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

Drops longest prefix of elements that satisfy a predicate.

Source

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

Tests whether this array ends with the given array.

Source

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

Tests whether this array ends with the given sequence.

Source

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

Tests whether a predicate holds for at least one element of this array.

Source

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

Selects all elements of this array which satisfy a predicate.

Source

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

Selects all elements of this array which do not satisfy a predicate.

Source

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

Finds the first element of the array satisfying a predicate, if any.

Source

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

Builds a new array by applying a function to all elements of this array and using the elements of the resulting collections.

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]

Flattens a two-dimensional array by concatenating all its rows into a single array.

Source

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

Folds the elements of this array using the specified associative binary operator.

Source

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

Applies a binary operator to a start value and all elements of this array, going left to right.

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

Source

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

Applies a binary operator to all elements of this array and a start value, going right to left.

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

Source

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

Tests whether a predicate holds for all elements of this array.

Source

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

Apply f to each element for its side effects. Note: [U] parameter needed to help scalac's type inference.

Source

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

Partitions this array into a map of arrays according to some discriminator function.

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

Partitions this array into a map of arrays according to a discriminator function key. Each element in a group is transformed into a value of type B using the value function.

It is equivalent to groupBy(key).mapValues(_.map(f)), but more efficient.

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

Partitions elements in fixed size arrays.

Source

def head: A

Selects the first element of this array.

Source

def headOption: Option[A]

Optionally selects the first element.

Source

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

Finds index of first occurrence of some value in this array after or at some start index.

Source

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

Finds index of the first element satisfying some predicate after or at some start index.

Source

def indices: Range

Produces the range of all indices of this sequence.

Source

def init: Array[A]

The initial part of the array without its last element.

Source

def inits: Iterator[Array[A]]

Iterates over the inits of this array. The first value will be this array and the final one will be an empty array, with the intervening values the results of successive applications of init.

Source

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

Computes the multiset intersection between this array and another sequence.

Source

def isEmpty: Boolean

Tests whether the array is empty.

Source

def iterator: Iterator[A]

Source

def knownSize: Int

The size of this array.

Source

def last: A

Selects the last element.

Source

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

Finds index of last occurrence of some value in this array before or at a given end index.

Source

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

Finds index of last element satisfying some predicate before or at given end index.

Source

def lastOption: Option[A]

Optionally selects the last element.

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Array[A]]

Analogous to zip except that the elements in each collection are not consumed until a strict operation is invoked on the returned LazyZip2 decorator.

Calls to lazyZip can be chained to support higher arities (up to 4) without incurring the expense of constructing and deconstructing intermediary tuples.

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

Compares the length of this array to a test value.

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

Source

def lengthIs: Int

Method mirroring SeqOps.lengthIs for consistency, except it returns an Int because length is known and comparison is constant-time.

These operations are equivalent to lengthCompare(Int), and allow the following more readable usages:

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]

Builds a new array by applying a function to all elements of this array.

Source

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

Source

def nonEmpty: Boolean

Tests whether the array is not empty.

Source

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

A copy of this array with an element value appended until a given target length is reached.

Source

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

A pair of, first, all elements that satisfy predicate p and, second, all elements that do not.

Source

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

Applies a function f to each element of the array and returns a pair of arrays: the first one made of those values returned by f that were wrapped in scala.util.Left, and the second one made of those wrapped in scala.util.Right.

Example:

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]

Returns a copy of this array with patched values. Patching at negative indices is the same as patching starting at 0. Patching at indices at or larger than the length of the original array appends the patch to the end. If more values are replaced than actually exist, the excess is ignored.

Source

def permutations: Iterator[Array[A]]

Iterates over distinct permutations.

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]

A copy of this array with an element prepended.

Source

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

A copy of this array with all elements of a collection prepended.

Source

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

A copy of this array with all elements of an array prepended.

Source

def reverse: Array[A]

Returns a new array with the elements in reversed order.

Source

def reverseIterator: Iterator[A]

An iterator yielding elements in reversed order.

Note: xs.reverseIterator is the same as xs.reverse.iterator but implemented more efficiently.

Source

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

Computes a prefix scan of the elements of the array.

Note: The neutral element z may be applied more than once.

Source

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

Produces an array containing cumulative results of applying the binary operator going left to right.

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]

Produces an array containing cumulative results of applying the binary operator going right to left.

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

Source

def size: Int

The size of this array.

Source

def sizeCompare(otherSize: Int): Int

Compares the size of this array to a test value.

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

Source

def sizeIs: Int

Method mirroring SeqOps.sizeIs for consistency, except it returns an Int because size is known and comparison is constant-time.

These operations are equivalent to sizeCompare(Int), and allow the following more readable usages:

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]

Selects an interval of elements. The returned array is made up of all elements x which satisfy the invariant:

from <= indexOf(x) < until

Source

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

Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)

Source

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

Sorts this array according to the Ordering which results from transforming an implicitly given Ordering with a transformation function.

Source

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

Sorts this array according to a comparison function.

The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted sequence as in the original.

Source

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

Sorts this array according to an Ordering.

The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted sequence as in the original.

Source

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

Splits this array into a prefix/suffix pair according to a predicate.

Note: c span p is equivalent to (but more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects.

Source

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

Splits this array into two at a given position. Note: c splitAt n is equivalent to (c take n, c drop n).

Source

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

Tests whether this array starts with the given array.

Source

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

Tests whether this array contains the given array at a given index.

Source

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

Tests whether this array contains the given sequence at a given index.

Source

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

Source

def tail: Array[A]

The rest of the array without its first element.

Source

def tails: Iterator[Array[A]]

Iterates over the tails of this array. The first value will be this array and the final one will be an empty array, with the intervening values the results of successive applications of tail.

Source

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

An array containing the first n elements of this array.

Source

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

An array containing the last n elements of this array.

Source

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

Takes longest prefix of elements that satisfy a predicate.

Source

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

Create a copy of this array with the specified element type.

Source

def toIndexedSeq: IndexedSeq[A]

Source

final def toSeq: Seq[A]

Source

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

Transposes a two dimensional array.

Source

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

Converts an array of pairs into an array of first elements and an array of second elements.

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

Converts an array of triples into three arrays, one containing the elements from each position of the triple.

Source

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

A copy of this array with one single replaced element.

Source

def view: IndexedSeqView[A]

Source

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

Creates a non-strict filter of this array.

Note: the difference between c filter p and c withFilter p is that the former creates a new array, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations.

Source

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

Returns an array formed from this array and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

Source

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

Returns an array formed from this array and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.

Source

def zipWithIndex: Array[(A, Int)]

Zips this array with its indices.