Class scala.collection.ArrayOps

Companion object ArrayOps

final class ArrayOps[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.

A: type of the elements contained in this array.

Source: ArrayOps.scala
Since: 2.8
Linear Supertypes: AnyVal, Any

Instance Constructors

new ArrayOps(xs: Array[A])

Value Members

final def !=(arg0: Any): Boolean

Test two objects for inequality.

returns: true if !(this == that), false otherwise.

Definition Classes: Any

final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null returns a hashcode where null.hashCode throws a NullPointerException.

returns: a hash value consistent with ==

Definition Classes: Any

def +(other: String): String

Implicit: This member is added by an implicit conversion from ArrayOps[A] toany2stringadd[ArrayOps[A]] performed by method any2stringadd in scala.Predef.
Definition Classes: any2stringadd

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

Annotations: @inline()

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

Annotations: @inline()

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

Annotations: @inline()

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

Annotations: @inline()

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

Annotations: @inline()

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

Implicit: This member is added by an implicit conversion from ArrayOps[A] toArrowAssoc[ArrayOps[A]] performed by method ArrowAssoc in scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @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

Test two objects for equality. The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

returns: true if the receiver object is equivalent to the argument; false otherwise.

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

Cast the receiver object to be of type T0.

Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

returns: the receiver object.

Definition Classes: Any
Exceptions thrown: ClassCastException if the receiver object is not an instance of the erasure of type T0.

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

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

B: the element type of the returned array.
pf: the partial function which filters and maps the array.
returns: a new array resulting from applying the given partial function pf to each element on which it is defined and collecting the results. The order of the elements is preserved.

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

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.

returns: An Iterator which traverses the possible n-element combinations of this array.

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

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

elem: the element to test.
returns: true if this array has an element that is equal (as determined by ==) to elem, false otherwise.

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.

B: the type of the elements of the array.
xs: the array to fill.
start: the starting index within the destination array.
len: the maximal number of elements to copy.

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.

B: the type of the elements of the array.
xs: the array to fill.
start: the starting index within the destination array.

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.

B: the type of the elements of the array.
xs: the array to fill.

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

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

Computes the multiset difference between this array and another sequence.

that: the sequence of elements to remove
returns: a new array which contains all elements of this array except some of occurrences of elements that also appear in that. If an element value x appears n times in that, then the first n occurrences of x will not form part of the result, but any following occurrences will.

def distinct: Array[A]

Selects all the elements of this array ignoring the duplicates.

returns: a new array consisting of all the elements of this array without duplicates.

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.

B: the type of the elements after being transformed by f
f: The transforming function whose result is used to determine the uniqueness of each element
returns: a new array consisting of all the elements of this array without duplicates.

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

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

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

Drops longest prefix of elements that satisfy a predicate.

p: The predicate used to test elements.
returns: the longest suffix of this array whose first element does not satisfy the predicate p.

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

Tests whether this array ends with the given sequence.

that: the sequence to test
returns: true if this array has that as a suffix, false otherwise.

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

Tests whether this array ends with the given array.

that: the array to test
returns: true if this array has that as a suffix, false otherwise.

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

Implicit: This member is added by an implicit conversion from ArrayOps[A] toEnsuring[ArrayOps[A]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

Implicit: This member is added by an implicit conversion from ArrayOps[A] toEnsuring[ArrayOps[A]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

Implicit: This member is added by an implicit conversion from ArrayOps[A] toEnsuring[ArrayOps[A]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

Implicit: This member is added by an implicit conversion from ArrayOps[A] toEnsuring[ArrayOps[A]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

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

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

returns: true if the given predicate p is satisfied by at least one element of this array, otherwise false

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

Selects all elements of this array which satisfy a predicate.

p: the predicate used to test elements.
returns: a new array consisting of all elements of this array that satisfy the given predicate p.

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

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

returns: a new array consisting of all elements of this array that do not satisfy the given predicate pred.

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

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

returns: an option value containing the first element in the array that satisfies p, or None if none exists.

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]

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

B: the element type of the returned array.
f: the function to apply to each element.
returns: a new array resulting from applying the given collection-valued function f to each element of this array and concatenating the results.

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.

B: Type of row elements.
asIterable: A function that converts elements of this array to rows - Iterables of type B.
returns: An array obtained by concatenating rows of this array.

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

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

A1: a type parameter for the binary operator, a supertype of A.
z: a neutral element for the fold operation; may be added to the result an arbitrary number of times, and must not change the result (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication).
op: a binary operator that must be associative.
returns: the result of applying the fold operator op between all the elements, or z if this array is empty.

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.

B

the result type of the binary operator.

z

the start value.

op

the binary operator.

returns

the result of inserting op between consecutive elements of this array, going left to right with the start value z on the left:

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

where x₁, ..., x_n are the elements of this array. Returns z if this array is empty.

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.

B

the result type of the binary operator.

z

the start value.

op

the binary operator.

returns

the result of inserting op between consecutive elements of this array, going right to left with the start value z on the right:

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

where x₁, ..., x_n are the elements of this array. Returns z if this array is empty.

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

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

returns: true if this array is empty or the given predicate p holds for all elements of this array, otherwise false.

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.

def formatted(fmtstr: String): String

Returns string formatted according to given format string. Format strings are as for String.format (@see java.lang.String.format).

Implicit: This member is added by an implicit conversion from ArrayOps[A] toStringFormat[ArrayOps[A]] performed by method StringFormat in scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

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

Returns the runtime class representation of the object.

returns: a class object corresponding to the runtime type of the receiver.

Definition Classes: AnyVal → Any

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

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

K

the type of keys returned by the discriminator function.

f

the discriminator function.

returns

A map from keys to arrays such that the following invariant holds:

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

That is, every key k is bound to an array of those elements x for which f(x) equals k.

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

K: the type of keys returned by the discriminator function
B: the type of values returned by the transformation function
key: the discriminator function
f: the element transformation function

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

Partitions elements in fixed size arrays.

size: the number of elements per group
returns: An iterator producing arrays of size size, except the last will be less than size size if the elements don't divide evenly.

See also: scala.collection.Iterator, method grouped

def head: A

Selects the first element of this array.

returns: the first element of this array.

Exceptions thrown: NoSuchElementException if the array is empty.

def headOption: Option[A]

Optionally selects the first element.

returns: the first element of this array if it is nonempty, None if it is empty.

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

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

elem: the element value to search for.
from: the start index
returns: the index >= from of the first element of this array that is equal (as determined by ==) to elem, or -1, if none exists.

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

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

from: the start index
returns: the index >= from of the first element of this array that satisfies the predicate p, or -1, if none exists.

def indices: immutable.Range

Produces the range of all indices of this sequence.

returns: a Range value from 0 to one less than the length of this array.

def init: Array[A]

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.

returns: an iterator over all the inits of this array

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

Computes the multiset intersection between this array and another sequence.

that: the sequence of elements to intersect with.
returns: a new array which contains all elements of this array which also appear in that. If an element value x appears n times in that, then the first n occurrences of x will be retained in the result, but any following occurrences will be omitted.

def isEmpty: Boolean

Tests whether the array is empty.

returns: true if the array contains no elements, false otherwise.

Annotations: @inline()

final def isInstanceOf[T0]: Boolean

Test whether the dynamic type of the receiver object is T0.

Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.

returns: true if the receiver object is an instance of erasure of type T0; false otherwise.

Definition Classes: Any

def iterator: Iterator[A]

def knownSize: Int

The size of this array.

returns: the number of elements in this array.

Annotations: @inline()

def last: A

Selects the last element.

returns: The last element of this array.

Exceptions thrown: NoSuchElementException If the array is empty.

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

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

elem: the element value to search for.
end: the end index.
returns: the index <= end of the last element of this array that is equal (as determined by ==) to elem, or -1, if none exists.

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

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

p: the predicate used to test elements.
returns: the index <= end of the last element of this array that satisfies the predicate p, or -1, if none exists.

def lastOption: Option[A]

Optionally selects the last element.

returns: the last element of this array$ if it is nonempty, None if it is empty.

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)

B: the type of the second element in each eventual pair
that: the iterable providing the second element of each eventual pair
returns: a decorator LazyZip2 that allows strict operations to be performed on the lazily evaluated pairs or chained calls to lazyZip. Implicit conversion to Iterable[(A, B)] is also supported.

def lengthCompare(len: Int): Int

Compares the length of this array to a test value.

len

the test value that gets compared with the length.

returns

A value x where

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

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

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.

B: the element type of the returned array.
f: the function to apply to each element.
returns: a new aray resulting from applying the given function f to each element of this array and collecting the results.

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

def nonEmpty: Boolean

Tests whether the array is not empty.

returns: true if the array contains at least one element, false otherwise.

Annotations: @inline()

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

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

B: the element type of the returned array.
len: the target length
elem: the padding value
returns: a new array consisting of all elements of this array followed by the minimal number of occurrences of elem so that the resulting collection has a length of at least 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])

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

A1: the element type of the first resulting collection
A2: the element type of the second resulting collection
f: the 'split function' mapping the elements of this array to an scala.util.Either
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.

def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int)(implicit arg0: ClassTag[B]): 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.

from: The start index from which to patch
other: The patch values
replaced: The number of values in the original array that are replaced by the patch.

def permutations: Iterator[Array[A]]

Iterates over distinct permutations.

returns: An Iterator which traverses the distinct permutations of this array.

Example:

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]

Returns a new array with the elements in reversed order.

Annotations: @inline()

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.

returns: an iterator yielding the elements of this array in reversed order

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

Computes a prefix scan of the elements of the array.

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

B: element type of the resulting array
z: neutral element for the operator op
op: the associative operator for the scan
returns: a new array containing the prefix scan of the elements in this array

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

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

B

the result type of the binary operator.

z

the start value.

op

the binary operator.

returns

array with intermediate values. Example:

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]

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

B

the result type of the binary operator.

z

the start value.

op

the binary operator.

returns

array with intermediate values. Example:

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

def size: Int

The size of this array.

returns: the number of elements in this array.

Annotations: @inline()

def sizeCompare(otherSize: Int): Int

Compares the size of this array to a test value.

otherSize

the test value that gets compared with the size.

returns

A value x where

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

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

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

from: the lowest index to include from this array.
until: the lowest index to EXCLUDE from this array.
returns: an array containing the elements greater than or equal to index from extending up to (but not including) index until of this array.

def sliding(size: Int, step: Int = 1): 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.)

size: the number of elements per group
step: the distance between the first elements of successive groups
returns: An iterator producing arrays of size size, except the last element (which may be the only element) will be truncated if there are fewer than size elements remaining to be grouped.

See also: scala.collection.Iterator, method sliding

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

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

B: the target type of the transformation f, and the type where the ordering ord is defined.
f: the transformation function mapping elements to some other domain B.
ord: the ordering assumed on domain B.
returns: an array consisting of the elements of this array sorted according to the ordering where x < y if ord.lt(f(x), f(y)).

See also: scala.math.Ordering

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.

lt: the comparison function which tests whether its first argument precedes its second argument in the desired ordering.
returns: an array consisting of the elements of this array sorted according to the comparison function lt.

def sorted[B >: A](implicit ord: math.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.

ord: the ordering to be used to compare elements.
returns: an array consisting of the elements of this array sorted according to the ordering ord.

See also: scala.math.Ordering

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.

p: the test predicate
returns: a pair consisting of the longest prefix of this array whose elements all satisfy p, and the rest of this array.

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

n: the position at which to split.
returns: a pair of arrays consisting of the first n elements of this array, and the other elements.

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

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

that: the sequence to test
offset: the index where the sequence is searched.
returns: true if the sequence that is contained in this array at index offset, otherwise false.

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

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

that: the array to test
offset: the index where the array is searched.
returns: true if the array that is contained in this array at index offset, otherwise false.

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

Tests whether this array starts with the given array.

Annotations: @inline()

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

def tail: Array[A]

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.

returns: an iterator over all the tails of this array

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

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

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

Takes longest prefix of elements that satisfy a predicate.

p: The predicate used to test elements.
returns: the longest prefix of this array whose elements all satisfy the predicate 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 a string representation of the object.

The default representation is platform dependent.

returns: a string representation of the object.

Definition Classes: Any

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

Transposes a two dimensional array.

B: Type of row elements.
asArray: A function that converts elements of this array to rows - arrays of type B.
returns: An array obtained by replacing elements of this arrays with rows the represent.

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.

A1: the type of the first half of the element pairs
A2: the type of the second half of the element pairs
asPair: an implicit conversion which asserts that the element type of this Array is a pair.
ct1: a class tag for A1 type parameter that is required to create an instance of Array[A1]
ct2: a class tag for A2 type parameter that is required to create an instance of Array[A2]
returns: a pair of Arrays, containing, respectively, the first and second half of each element pair of this Array.

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.

A1: the type of the first of three elements in the triple
A2: the type of the second of three elements in the triple
A3: the type of the third of three elements in the triple
asTriple: an implicit conversion which asserts that the element type of this Array is a triple.
ct1: a class tag for T1 type parameter that is required to create an instance of Array[T1]
ct2: a class tag for T2 type parameter that is required to create an instance of Array[T2]
ct3: a class tag for T3 type parameter that is required to create an instance of Array[T3]
returns: a triple of Arrays, containing, respectively, the first, second, and third elements from each element triple of this Array.

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

A copy of this array with one single replaced element.

index: the position of the replacement
elem: the replacing element
returns: a new array which is a copy of this array with the element at position index replaced by elem.

Exceptions thrown: IndexOutOfBoundsException if index does not satisfy 0 <= index < length.

def view: IndexedSeqView[A]

Annotations: @inline()

def withFilter(p: (A) => Boolean): ArrayOps.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.

p: the predicate used to test elements.
returns: an object of class ArrayOps.WithFilter, which supports map, flatMap, foreach, and withFilter operations. All these operations apply to those elements of this array which satisfy the predicate p.

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.

B: the type of the second half of the returned pairs
that: The iterable providing the second half of each result pair
returns: a new array containing pairs consisting of corresponding elements of this array and that. The length of the returned array is the minimum of the lengths of this array and that.

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.

that: the iterable providing the second half of each result pair
thisElem: the element to be used to fill up the result if this array is shorter than that.
thatElem: the element to be used to fill up the result if that is shorter than this array.
returns: a new array containing pairs consisting of corresponding elements of this array and that. The length of the returned array is the maximum of the lengths of this array and that. If this array is shorter than that, thisElem values are used to pad the result. If that is shorter than this array, thatElem values are used to pad the result.

def zipWithIndex: Array[(A, Int)]

Zips this array with its indices.

returns: A new array containing pairs consisting of all elements of this array paired with their index. Indices start at 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