final class ArrayOps[A] extends AnyVal
This class serves as a wrapper for Array
s 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 ArraySeq
s 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
- Alphabetic
- By Inheritance
- ArrayOps
- AnyVal
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
Test two objects for inequality.
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 andnull
.Equivalent to
x.hashCode
except for boxed numeric types andnull
. 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. Fornull
returns a hashcode wherenull.hashCode
throws aNullPointerException
.- 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.
Test two objects for equality. The expression
x == that
is equivalent toif (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]
A copy of this array with an element appended.
- def appendedAll[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
A copy of this array with all elements of an array appended.
- def appendedAll[B >: A](suffix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
A copy of this array with all elements of a collection appended.
- final def asInstanceOf[T0]: T0
Cast the receiver object to be of type
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 aClassCastException
at runtime, while the expressionList(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 typeT0
.
- 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.
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]
Finds the first element of the array for which the given partial function is defined, and applies the partial function to it.
- def combinations(n: Int): Iterator[Array[A]]
Iterates over combinations.
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")
andArray("y", "y")
are both length-2 combinations ofArray("x", "y", "y")
, butArray("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 generateArray("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.
Array("a", "b", "b", "b", "c").combinations(2) == Iterator(Array(a, b), Array(a, c), Array(b, b), Array(b, c))
Example: - 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.
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==
) toelem
,false
otherwise.
- def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
Copy elements of this array to another array.
Copy elements of this array to another array. Fills the given array
xs
starting at indexstart
with at mostlen
values. Copying will stop once either all the elements of this array have been copied, or the end of the array is reached, orlen
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.
Copy elements of this array to another array. Fills the given array
xs
starting at indexstart
. 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.
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
Counts the number of elements in this array which satisfy a predicate
- def diff[B >: A](that: Seq[B]): Array[A]
Computes the multiset difference between this array and another sequence.
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 valuex
appears n times inthat
, then the first n occurrences ofx
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.
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 functionf
.Selects all the elements of this array ignoring the duplicates as determined by
==
after applying the transforming functionf
.- 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]
The rest of the array without its
n
first elements. - def dropRight(n: Int): Array[A]
The rest of the array without its
n
last elements. - def dropWhile(p: (A) => Boolean): Array[A]
Drops longest prefix of elements that satisfy a predicate.
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.
Tests whether this array ends with the given sequence.
- that
the sequence to test
- returns
true
if this array hasthat
as a suffix,false
otherwise.
- def endsWith[B >: A](that: Array[B]): Boolean
Tests whether this array ends with the given array.
Tests whether this array ends with the given array.
- that
the array to test
- returns
true
if this array hasthat
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.
Tests whether a predicate holds for at least one element of this array.
- returns
true
if the given predicatep
is satisfied by at least one element of this array, otherwisefalse
- def filter(p: (A) => Boolean): Array[A]
Selects all elements of this array which satisfy a predicate.
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.
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.
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
, orNone
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.
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.
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.
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, orz
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.
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 valuez
on the left:op(...op(z, x_1), x_2, ..., x_n)
where
x_{1}, ..., x_{n}
are the elements of this array. Returnsz
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.
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 valuez
on the right:op(x_1, op(x_2, ... op(x_n, z)...))
where
x_{1}, ..., x_{n}
are the elements of this array. Returnsz
if this array is empty.
- def forall(f: (A) => Boolean): Boolean
Tests whether a predicate holds for all elements of this array.
Tests whether a predicate holds for all elements of this array.
- returns
true
if this array is empty or the given predicatep
holds for all elements of this array, otherwisefalse
.
- def foreach[U](f: (A) => U): Unit
Apply
f
to each element for its side effects.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.Returns string formatted according to given
format
string. Format strings are as forString.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.
- def groupBy[K](f: (A) => K): immutable.Map[K, Array[A]]
Partitions this array into a map of arrays according to some discriminator function.
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 elementsx
for whichf(x)
equalsk
.
- 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
.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 typeB
using thevalue
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.
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 sizesize
if the elements don't divide evenly.
- See also
scala.collection.Iterator, method
grouped
- def head: A
Selects the first element of this array.
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.
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.
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==
) toelem
, 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.
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 predicatep
, or-1
, if none exists.
- def indices: immutable.Range
Produces the range of all indices of this sequence.
Produces the range of all indices of this sequence.
- returns
a
Range
value from0
to one less than the length of this array.
- def init: Array[A]
The initial part of the array without its last element.
- def inits: Iterator[Array[A]]
Iterates over the inits of this array.
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.
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 valuex
appears n times inthat
, then the first n occurrences ofx
will be retained in the result, but any following occurrences will be omitted.
- def isEmpty: Boolean
Tests whether the array is empty.
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
.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 returnfalse
, while the expressionList(1).isInstanceOf[List[String]]
will returntrue
. 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 typeT0
;false
otherwise.
- Definition Classes
- Any
- def iterator: Iterator[A]
- def knownSize: Int
The size of this array.
- def last: A
Selects the last element.
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.
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==
) toelem
, 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.
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 predicatep
, or-1
, if none exists.
- def lastOption: Option[A]
Optionally selects the last element.
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 returnedLazyZip2
decorator.Analogous to
zip
except that the elements in each collection are not consumed until a strict operation is invoked on the returnedLazyZip2
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 tolazyZip
. Implicit conversion toIterable[(A, B)]
is also supported.
- def lengthCompare(len: Int): Int
Compares the length of this array to a test value.
Compares the length of this array to a test value.
- len
the test value that gets compared with the length.
- returns
A value
x
wherex < 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
becauselength
is known and comparison is constant-time.Method mirroring SeqOps.lengthIs for consistency, except it returns an
Int
becauselength
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.
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.
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.
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 leastlen
.
- 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. - 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 byf
that were wrapped in scala.util.Left, and the second one made of those wrapped in scala.util.Right.Applies a function
f
to each element of the array and returns a pair of arrays: the first one made of those values returned byf
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.
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.
Iterates over distinct permutations.
- returns
An Iterator which traverses the distinct permutations of this array.
Array("a", "b", "b").permutations == Iterator(Array(a, b, b), Array(b, a, b), Array(b, b, a))
Example: - def prepended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
A copy of this array with an element prepended.
- def prependedAll[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
A copy of this array with all elements of an array prepended.
- def prependedAll[B >: A](prefix: IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
A copy of this array with all elements of a collection prepended.
- def reverse: Array[A]
Returns a new array with the elements in reversed order.
Returns a new array with the elements in reversed order.
- Annotations
- @inline()
- def reverseIterator: Iterator[A]
An iterator yielding elements in reversed order.
An iterator yielding elements in reversed order.
Note:
xs.reverseIterator
is the same asxs.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.
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.
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.
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.
- def sizeCompare(otherSize: Int): Int
Compares the size of this array to a test value.
Compares the size of this array to a test value.
- otherSize
the test value that gets compared with the size.
- returns
A value
x
wherex < 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
becausesize
is known and comparison is constant-time.Method mirroring SeqOps.sizeIs for consistency, except it returns an
Int
becausesize
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.
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) indexuntil
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.)
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 thansize
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.
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 orderingord
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
iford.lt(f(x), f(y))
.
- See also
- def sortWith(lt: (A, A) => Boolean): Array[A]
Sorts this array according to a comparison 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.- 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.
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
- def span(p: (A) => Boolean): (Array[A], Array[A])
Splits this array into a prefix/suffix pair according to a predicate.
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 predicatep
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.
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.
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 sequencethat
is contained in this array at indexoffset
, otherwisefalse
.
- def startsWith[B >: A](that: Array[B], offset: Int): Boolean
Tests whether this array contains the given array at a given index.
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 arraythat
is contained in this array at indexoffset
, otherwisefalse
.
- def startsWith[B >: A](that: Array[B]): Boolean
Tests whether this array starts with the given array.
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]
The rest of the array without its first element.
- def tails: Iterator[Array[A]]
Iterates over the tails of this 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
.- returns
an iterator over all the tails of this array
- def take(n: Int): Array[A]
An array containing the first
n
elements of this array. - def takeRight(n: Int): Array[A]
An array containing the last
n
elements of this array. - def takeWhile(p: (A) => Boolean): Array[A]
Takes longest prefix of elements that satisfy a predicate.
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]
Create a copy of this array with the specified element type.
- def toIndexedSeq: immutable.IndexedSeq[A]
- final def toSeq: immutable.Seq[A]
- Annotations
- @inline()
- def toString(): String
Returns a string representation of the object.
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.
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.
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 ofArray[A1]
- ct2
a class tag for
A2
type parameter that is required to create an instance ofArray[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.
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.
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 byelem
.
- Exceptions thrown
IndexOutOfBoundsException
ifindex
does not satisfy0 <= index < length
.
- def view: IndexedSeqView[A]
- Annotations
- @inline()
- def withFilter(p: (A) => Boolean): ArrayOps.WithFilter[A]
Creates a non-strict filter of this array.
Creates a non-strict filter of this array.
Note: the difference between
c filter p
andc withFilter p
is that the former creates a new array, whereas the latter only restricts the domain of subsequentmap
,flatMap
,foreach
, andwithFilter
operations.- p
the predicate used to test elements.
- returns
an object of class
ArrayOps.WithFilter
, which supportsmap
,flatMap
,foreach
, andwithFilter
operations. All these operations apply to those elements of this array which satisfy the predicatep
.
- 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.
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 andthat
.
- 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.
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 andthat
. If this array is shorter thanthat
,thisElem
values are used to pad the result. Ifthat
is shorter than this array,thatElem
values are used to pad the result.
- def zipWithIndex: Array[(A, Int)]
Zips this array with its indices.
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
.
Deprecated Value Members
- 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
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.collection.parallel
- Parallel collections (scala-parallel-collections.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.