Test two objects for inequality.

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.

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

Forces the compiler to treat the receiver object as having type T0, even though doing so may violate type safety.

This method is useful when you believe you have type information the compiler doesn't, and it also isn't possible to check the type at runtime. In such situations, skipping type safety is the only option.

It is platform dependent whether asInstanceOf has any effect at runtime. It might do a runtime type test on the erasure of T0, insert a conversion (such as boxing/unboxing), fill in a default value, or do nothing at all.

In particular, asInstanceOf is not a type test. It does **not** mean:

this match {
 case x: T0 => x
 case _     => throw ClassCastException("...")

Use pattern matching or isInstanceOf for type testing instead.

Situations where asInstanceOf is useful:

• when flow analysis fails to deduce T0 automatically
• when down-casting a type parameter or an abstract type member (which cannot be checked at runtime due to type erasure) If there is any doubt and you are able to type test instead, you should do so.

Be careful of using asInstanceOf when T0 is a primitive type. When T0 is primitive, asInstanceOf may insert a conversion instead of a type test. If your intent is to convert, use a toT method (x.toChar, x.toByte, etc.).

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

Iterates over combinations of elements.

A combination of length n is a sequence of n elements selected in order of their first index in this sequence.

For example, "xyx" has two combinations of length 2. The x is selected first: "xx", "xy". The sequence "yx" is not returned as a combination because it is subsumed by "xy".

If there is more than one way to generate the same combination, only one will be returned.

For example, the result "xy" arbitrarily selected one of the x elements.

As a further illustration, "xyxx" has three different ways to generate "xy" because there are three elements x to choose from. Moreover, there are three unordered pairs "xx" but only one is returned.

It is not specified which of these equal combinations is returned. It is an implementation detail that should not be relied on. For example, the combination "xx" does not necessarily contain the first x in this sequence. This behavior is observable if the elements compare equal but are not identical.

As a consequence, "xyx".combinations(3).next() is "xxy": the combination does not reflect the order of the original sequence, but the order in which elements were selected, by "first index"; the order of each x element is also arbitrary.

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

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.

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.

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.

Computes the multiset difference between this array and another sequence.

Selects all the elements of this array ignoring the duplicates.

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

Drops longest prefix of elements that satisfy a predicate.

Tests whether this array ends with the given sequence.

Tests whether this array ends with the given array.

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

Selects all elements of this array which satisfy a predicate.

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

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

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

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

Alias for foldLeft.

The type parameter is more restrictive than for foldLeft to be consistent with IterableOnceOps.fold.

Applies the given binary operator op to the given initial value z and all elements of this array, going left to right. Returns the initial value if this array is empty.

If x1, x2, ..., xn are the elements of this array, the result is op( op( ... op( op(z, x1), x2) ... ), xn).

Applies the given binary operator op to all elements of this array and the given initial value z, going right to left. Returns the initial value if this array is empty.

If x1, x2, ..., xn are the elements of this array, the result is op(x1, op(x2, op( ... op(xn, z) ... ))).

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

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

Returns the runtime class representation of the object.

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

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)

Partitions elements in fixed size arrays.

Selects the first element of this array.

Optionally selects the first element.

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

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

Produces the range of all indices of this sequence.

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.

Computes the multiset intersection between this array and another sequence.

Tests whether the array is empty.

Test whether the dynamic type of the receiver object has the same erasure as T0.

Depending on what T0 is, the test is done in one of the below ways:

• T0 is a non-parameterized class type, e.g. BigDecimal: this method returns true if the value of the receiver object is a BigDecimal or a subtype of BigDecimal.
• T0 is a parameterized class type, e.g. List[Int]: this method returns true if the value of the receiver object is some List[X] for any X. For example, List(1, 2, 3).isInstanceOf[List[String]] will return true.
• T0 is some singleton type x.type or literal x: this method returns this.eq(x). For example, x.isInstanceOf[1] is equivalent to x.eq(1)
• T0 is an intersection X with Y or X & Y: this method is equivalent to x.isInstanceOf[X] && x.isInstanceOf[Y]
• T0 is a union X | Y: this method is equivalent to x.isInstanceOf[X] || x.isInstanceOf[Y]
• T0 is a type parameter or an abstract type member: this method is equivalent to isInstanceOf[U] where U is T0's upper bound, Any if T0 is unbounded. For example, x.isInstanceOf[A] where A is an unbounded type parameter will return true for any value of x.

This is exactly equivalent to the type pattern _: T0

The size of this array.

Selects the last element.

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

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

Optionally selects the last element.

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)

Compares the length of this array to a test value.

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

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

Tests whether the array is not empty.

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

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

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.

Iterates over distinct permutations of elements.

Returns a new array with the elements in reversed order.

An iterator yielding elements in reversed order.

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

Computes a prefix scan of the elements of the array.

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

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

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

The size of this array.

Compares the size of this array to a test value.

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

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

from <= indexOf(x) < until

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

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

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.

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.

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.

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

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

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

Tests whether this array starts with the given array.

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.

Takes longest prefix of elements that satisfy a predicate.

Returns a string representation of the object.

The default representation is platform dependent.

Transposes a two dimensional array.

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

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

A copy of this array with one single replaced element.

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.

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.

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.

Zips this array with its indices.

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