Object Array.Array

object Array

Utility methods for operating on arrays. For example:

val a = Array(1, 2)
val b = Array.ofDim[Int](2)
val c = Array.concat(a, b)

where the array objects a, b and c have respectively the values Array(1, 2), Array(0, 0) and Array(1, 2, 0, 0).

Supertypes	class Object trait Matchable class Any
Self type	Array.type

Classlikes

Source

final class UnapplySeqWrapper[T](a: Array[T]) extends AnyVal

Concrete methods

Source

def apply[T : ClassTag](xs: T*): Array[T]

Creates an array with given elements.

Value parameters	xs the elements to put in the array
Returns	an array containing all elements from xs.

Source

def apply(x: Boolean, xs: Boolean*): Array[Boolean]

Creates an array of Boolean objects

Source

def apply(x: Byte, xs: Byte*): Array[Byte]

Creates an array of Byte objects

Source

def apply(x: Short, xs: Short*): Array[Short]

Creates an array of Short objects

Source

def apply(x: Char, xs: Char*): Array[Char]

Creates an array of Char objects

Source

def apply(x: Int, xs: Int*): Array[Int]

Creates an array of Int objects

Source

def apply(x: Long, xs: Long*): Array[Long]

Creates an array of Long objects

Source

def apply(x: Float, xs: Float*): Array[Float]

Creates an array of Float objects

Source

def apply(x: Double, xs: Double*): Array[Double]

Creates an array of Double objects

Source

def apply(x: Unit, xs: Unit*): Array[Unit]

Creates an array of Unit objects

Source

def concat[T : ClassTag](xss: Array[T]*): Array[T]

Concatenates all arrays into a single array.

Value parameters	xss the given arrays
Returns	the array created from concatenating xss

Source

def copy(src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int): Unit

Copy one array to another. Equivalent to Java's System.arraycopy(src, srcPos, dest, destPos, length), except that this also works for polymorphic and boxed arrays.

Note that the passed-in dest array will be modified by this call.

Value parameters	dest destination array. destPos starting position in the destination array. length the number of array elements to be copied. src the source array. srcPos starting position in the source array.
See also	java.lang.System#arraycopy

Source

def copyAs[A](original: Array[_], newLength: Int)(implicit ct: ClassTag[A]): Array[A]

Copy one array to another, truncating or padding with default values (if necessary) so the copy has the specified length. The new array can have a different type than the original one as long as the values are assignment-compatible. When copying between primitive and object arrays, boxing and unboxing are supported.

Equivalent to Java's java.util.Arrays.copyOf(original, newLength, newType), except that this works for all combinations of primitive and object arrays in a single method.

See also	java.util.Arrays#copyOf

Source

def copyOf[A](original: Array[A], newLength: Int): Array[A]

Copy one array to another, truncating or padding with default values (if necessary) so the copy has the specified length.

Equivalent to Java's java.util.Arrays.copyOf(original, newLength), except that this works for primitive and object arrays in a single method.

See also	java.util.Arrays#copyOf

Source

def empty[T : ClassTag]: Array[T]

Returns an array of length 0

Source

def equals(xs: Array[AnyRef], ys: Array[AnyRef]): Boolean

Compare two arrays per element.

A more efficient version of xs.sameElements(ys).

Note that arrays are invariant in Scala, but it may be sound to cast an array of arbitrary reference type to Array[AnyRef]. Arrays on the JVM are covariant in their element type.

Array.equals(xs.asInstanceOf[Array[AnyRef]], ys.asInstanceOf[Array[AnyRef]])

Value parameters	xs an array of AnyRef ys an array of AnyRef
Returns	true if corresponding elements are equal

Source

def fill[T : ClassTag](n: Int)(elem: => T): Array[T]

Returns an array that contains the results of some element computation a number of times.

Note that this means that elem is computed a total of n times:

scala> Array.fill(3){ math.random }
res3: Array[Double] = Array(0.365461167592537, 1.550395944913685E-4, 0.7907242137333306)

Value parameters	elem the element computation n the number of elements desired
Returns	an Array of size n, where each element contains the result of computing elem.

Source

def fill[T : ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]]

Returns a two-dimensional array that contains the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension

Source

def fill[T : ClassTag](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]]

Returns a three-dimensional array that contains the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension

Source

def fill[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]]

Returns a four-dimensional array that contains the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension

Source

def fill[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]]

Returns a five-dimensional array that contains the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension n5 the number of elements in the 5th dimension

Source

def from[A : ClassTag](it: IterableOnce[A]): Array[A]

Build an array from the iterable collection.

scala> val a = Array.from(Seq(1, 5))
val a: Array[Int] = Array(1, 5)

scala> val b = Array.from(Range(1, 5))
val b: Array[Int] = Array(1, 2, 3, 4)

Value parameters	it the iterable collection
Returns	an array consisting of elements of the iterable collection

Source

def iterate[T : ClassTag](start: T, len: Int)(f: T => T): Array[T]

Returns an array containing repeated applications of a function to a start value.

Value parameters	f the function that is repeatedly applied len the number of elements returned by the array start the start value of the array
Returns	the array returning len values in the sequence start, f(start), f(f(start)), ...

Source

def newBuilder[T](implicit t: ClassTag[T]): ArrayBuilder[T]

Returns a new scala.collection.mutable.ArrayBuilder.

Source

def ofDim[T : ClassTag](n1: Int): Array[T]

Creates array with given dimensions

Source

def ofDim[T : ClassTag](n1: Int, n2: Int): Array[Array[T]]

Creates a 2-dimensional array

Source

def ofDim[T : ClassTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]]

Creates a 3-dimensional array

Source

def ofDim[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]]

Creates a 4-dimensional array

Source

def ofDim[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]]

Creates a 5-dimensional array

Source

def range(start: Int, end: Int): Array[Int]

Returns an array containing a sequence of increasing integers in a range.

Value parameters	end the end value of the array, exclusive (in other words, this is the first value not returned) start the start value of the array
Returns	the array with values in range start, start + 1, ..., end - 1 up to, but excluding, end.

Source

def range(start: Int, end: Int, step: Int): Array[Int]

Returns an array containing equally spaced values in some integer interval.

Value parameters	end the end value of the array, exclusive (in other words, this is the first value not returned) start the start value of the array step the increment value of the array (may not be zero)
Returns	the array with values in start, start + step, ... up to, but excluding end

Source

def tabulate[T : ClassTag](n: Int)(f: Int => T): Array[T]

Returns an array containing values of a given function over a range of integer values starting from 0.

Value parameters	f The function computing element values n The number of elements in the array
Returns	A traversable consisting of elements f(0),f(1), ..., f(n - 1)

Source

def tabulate[T : ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]]

Returns a two-dimensional array containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension

Source

def tabulate[T : ClassTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]]

Returns a three-dimensional array containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension

Source

def tabulate[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]]

Returns a four-dimensional array containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension

Source

def tabulate[T : ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]]

Returns a five-dimensional array containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension n5 the number of elements in the 5th dimension

Source

def unapplySeq[T](x: Array[T]): UnapplySeqWrapper[T]

Called in a pattern match like { case Array(x,y,z) => println('3 elements')}.

Value parameters	x the selector value
Returns	sequence wrapped in a scala.Some, if x is an Array, otherwise None

Concrete fields

Source

val emptyBooleanArray: Array[Boolean]

Source

val emptyByteArray: Array[Byte]

Source

val emptyCharArray: Array[Char]

Source

val emptyDoubleArray: Array[Double]

Source

val emptyFloatArray: Array[Float]

Source

val emptyIntArray: Array[Int]

Source

val emptyLongArray: Array[Long]

Source

val emptyObjectArray: Array[Object]

Source

val emptyShortArray: Array[Short]

Implicits

Source

implicit def toFactory[A : ClassTag](dummy: Array.type): Factory[A, Array[A]]

Provides an implicit conversion from the Array object to a collection Factory