scala.collection.mutable.ArrayBuffer

object ArrayBuffer extends SeqFactory[ArrayBuffer] with Serializable

Factory object for the ArrayBuffer class.

This object provides a set of operations to create ArrayBuffer values.

Type Members

type Coll = ArrayBuffer[_]

The underlying collection type with unknown element type

  • Attributes
    • protected[this]
  • Definition Classes
    • GenericCompanion

class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]]

A generic implementation of the CanBuildFrom trait, which forwards all calls to apply(from) to the genericBuilder method of collection from , and which forwards all calls of apply() to the newBuilder method of this factory.

  • Definition Classes
    • GenTraversableFactory

Value Members From scala.collection.generic.GenTraversableFactory

def ReusableCBF: GenericCanBuildFrom[Nothing]

  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def concat[A](xss: collection.Traversable[A]*): ArrayBuffer[A]

Concatenates all argument collections into a single collection.

  • xss
    • the collections that are to be concatenated.
  • returns
    • the concatenation of all the collections.
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def fill[A](n: Int)(elem: ⇒ A): ArrayBuffer[A]

Produces a collection containing the results of some element computation a number of times.

  • n
    • the number of elements contained in the collection.
  • elem
    • the element computation
  • returns
    • A collection that contains the results of n evaluations of elem .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def fill[A](n1: Int, n2: Int)(elem: ⇒ A): ArrayBuffer[ArrayBuffer[A]]

Produces a two-dimensional collection containing the results of some element computation a number of times.

  • n1
    • the number of elements in the 1st dimension
  • n2
    • the number of elements in the 2nd dimension
  • elem
    • the element computation
  • returns
    • A collection that contains the results of n1 x n2 evaluations of elem .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def fill[A](n1: Int, n2: Int, n3: Int)(elem: ⇒ A): ArrayBuffer[ArrayBuffer[ArrayBuffer[A]]]

Produces a three-dimensional collection containing the results of some element computation a number of times.

  • 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 3nd dimension
  • elem
    • the element computation
  • returns
    • A collection that contains the results of n1 x n2 x n3 evaluations of elem .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: ⇒ A): ArrayBuffer[ArrayBuffer[ArrayBuffer[ArrayBuffer[A]]]]

Produces a four-dimensional collection containing the results of some element computation a number of times.

  • 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 3nd dimension
  • n4
    • the number of elements in the 4th dimension
  • elem
    • the element computation
  • returns
    • A collection that contains the results of n1 x n2 x n3 x n4 evaluations of elem .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: ⇒ A): ArrayBuffer[ArrayBuffer[ArrayBuffer[ArrayBuffer[ArrayBuffer[A]]]]]

Produces a five-dimensional collection containing the results of some element computation a number of times.

  • 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 3nd dimension
  • n4
    • the number of elements in the 4th dimension
  • n5
    • the number of elements in the 5th dimension
  • elem
    • the element computation
  • returns
    • A collection that contains the results of n1 x n2 x n3 x n4 x n5 evaluations of elem .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def iterate[A](start: A, len: Int)(f: (A) ⇒ A): ArrayBuffer[A]

Produces a collection containing repeated applications of a function to a start value.

  • start
    • the start value of the collection
  • len
    • the number of elements contained inthe collection
  • f
    • the function that’s repeatedly applied
  • returns
    • a collection with len values in the sequence start, f(start), f(f(start)), ...
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def range[T](start: T, end: T)(implicit arg0: Integral[T]): ArrayBuffer[T]

Produces a collection containing a sequence of increasing of integers.

  • start
    • the first element of the collection
  • end
    • the end value of the collection (the first value NOT contained)
  • returns
    • a collection with values start, start + 1, ..., end - 1
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def range[T](start: T, end: T, step: T)(implicit arg0: Integral[T]): ArrayBuffer[T]

Produces a collection containing equally spaced values in some integer interval.

  • start
    • the start value of the collection
  • end
    • the end value of the collection (the first value NOT contained)
  • step
    • the difference between successive elements of the collection (must be positive or negative)
  • returns
    • a collection with values start, start + step, ... up to, but excluding end
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def tabulate[A](n: Int)(f: (Int) ⇒ A): ArrayBuffer[A]

Produces a collection containing values of a given function over a range of integer values starting from 0.

  • n
    • The number of elements in the collection
  • f
    • The function computing element values
  • returns
    • A collection consisting of elements f(0), ..., f(n -1)
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) ⇒ A): ArrayBuffer[ArrayBuffer[A]]

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

  • n1
    • the number of elements in the 1st dimension
  • n2
    • the number of elements in the 2nd dimension
  • f
    • The function computing element values
  • returns
    • A collection consisting of elements f(i1, i2) for 0 <= i1 < n1 and 0 <= i2 < n2 .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) ⇒ A): ArrayBuffer[ArrayBuffer[ArrayBuffer[A]]]

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

  • 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 3nd dimension
  • f
    • The function computing element values
  • returns
    • A collection consisting of elements f(i1, i2, i3) for 0 <= i1 < n1 , 0 <= i2 < n2 , and 0 <= i3 < n3 .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) ⇒ A): ArrayBuffer[ArrayBuffer[ArrayBuffer[ArrayBuffer[A]]]]

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

  • 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 3nd dimension
  • n4
    • the number of elements in the 4th dimension
  • f
    • The function computing element values
  • returns
    • A collection consisting of elements f(i1, i2, i3, i4) for 0 <= i1 < n1 , 0 <= i2 < n2 , 0 <= i3 < n3 , and 0 <= i4 < n4 .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) ⇒ A): ArrayBuffer[ArrayBuffer[ArrayBuffer[ArrayBuffer[ArrayBuffer[A]]]]]

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

  • 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 3nd dimension
  • n4
    • the number of elements in the 4th dimension
  • n5
    • the number of elements in the 5th dimension
  • f
    • The function computing element values
  • returns
    • A collection consisting of elements f(i1, i2, i3, i4, i5) for 0 <= i1 < n1 , 0 <= i2 < n2 , 0 <= i3 < n3 , 0 <= i4 < n4 , and 0 <= i5 < n5 .
  • Definition Classes
    • GenTraversableFactory

(defined at scala.collection.generic.GenTraversableFactory)

Value Members From scala.collection.generic.GenericCompanion

def apply[A](elems: A*): ArrayBuffer[A]

Creates a collection with the specified elements.

  • A
    • the type of the collection’s elements
  • elems
    • the elements of the created collection
  • returns
    • a new collection with elements elems
  • Definition Classes
    • GenericCompanion

(defined at scala.collection.generic.GenericCompanion)

def empty[A]: ArrayBuffer[A]

An empty collection of type CC[A]

  • A
    • the type of the collection’s elements
  • Definition Classes
    • GenericCompanion

(defined at scala.collection.generic.GenericCompanion)

Value Members From scala.collection.generic.SeqFactory

def unapplySeq[A](x: ArrayBuffer[A]): Some[ArrayBuffer[A]]

This method is called in a pattern match { case Seq(…) => }.

  • x
    • the selector value
  • returns
    • sequence wrapped in an option, if this is a Seq, otherwise none
  • Definition Classes
    • SeqFactory

(defined at scala.collection.generic.SeqFactory)

Value Members From scala.collection.mutable.ArrayBuffer

implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, ArrayBuffer[A]]

The standard CanBuildFrom instance for ArrayBuffer objects. The created value is an instance of class GenericCanBuildFrom , which forwards calls to create a new builder to the genericBuilder method of the requesting collection.

(defined at scala.collection.mutable.ArrayBuffer)

def newBuilder[A]: Builder[A, ArrayBuffer[A]]

The default builder for ArrayBuffer objects.

  • A
    • the type of the array buffer’s elements
  • Definition Classes
    • ArrayBuffer → GenericCompanion (defined at scala.collection.mutable.ArrayBuffer)

Full Source:

/*                     __                                               *\
**     ________ ___   / /  ___     Scala API                            **
**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
** /____/\___/_/ |_/____/_/ | |                                         **
**                          |/                                          **
\*                                                                      */



package scala
package collection
package mutable

import generic._
import parallel.mutable.ParArray

/** An implementation of the `Buffer` class using an array to
 *  represent the assembled sequence internally. Append, update and random
 *  access take constant time (amortized time). Prepends and removes are
 *  linear in the buffer size.
 *
 *  @author  Matthias Zenger
 *  @author  Martin Odersky
 *  @version 2.8
 *  @since   1
 *  @see [[http://docs.scala-lang.org/overviews/collections/concrete-mutable-collection-classes.html#array_buffers "Scala's Collection Library overview"]]
 *  section on `Array Buffers` for more information.

 *
 *  @tparam A    the type of this arraybuffer's elements.
 *
 *  @define Coll `mutable.ArrayBuffer`
 *  @define coll array buffer
 *  @define thatinfo the class of the returned collection. In the standard library configuration,
 *    `That` is always `ArrayBuffer[B]` because an implicit of type `CanBuildFrom[ArrayBuffer, B, ArrayBuffer[B]]`
 *    is defined in object `ArrayBuffer`.
 *  @define bfinfo an implicit value of class `CanBuildFrom` which determines the
 *    result class `That` from the current representation type `Repr`
 *    and the new element type `B`. This is usually the `canBuildFrom` value
 *    defined in object `ArrayBuffer`.
 *  @define orderDependent
 *  @define orderDependentFold
 *  @define mayNotTerminateInf
 *  @define willNotTerminateInf
 */
@SerialVersionUID(1529165946227428979L)
class ArrayBuffer[A](override protected val initialSize: Int)
  extends AbstractBuffer[A]
     with Buffer[A]
     with GenericTraversableTemplate[A, ArrayBuffer]
     with BufferLike[A, ArrayBuffer[A]]
     with IndexedSeqOptimized[A, ArrayBuffer[A]]
     with Builder[A, ArrayBuffer[A]]
     with ResizableArray[A]
     with CustomParallelizable[A, ParArray[A]]
     with Serializable {

  override def companion: GenericCompanion[ArrayBuffer] = ArrayBuffer

  import scala.collection.Traversable

  def this() = this(16)

  def clear() { reduceToSize(0) }

  override def sizeHint(len: Int) {
    if (len > size && len >= 1) {
      val newarray = new Array[AnyRef](len)
      scala.compat.Platform.arraycopy(array, 0, newarray, 0, size0)
      array = newarray
    }
  }

  override def par = ParArray.handoff[A](array.asInstanceOf[Array[A]], size)

  /** Appends a single element to this buffer and returns
   *  the identity of the buffer. It takes constant amortized time.
   *
   *  @param elem  the element to append.
   *  @return      the updated buffer.
   */
  def +=(elem: A): this.type = {
    ensureSize(size0 + 1)
    array(size0) = elem.asInstanceOf[AnyRef]
    size0 += 1
    this
  }

  /** Appends a number of elements provided by a traversable object.
   *  The identity of the buffer is returned.
   *
   *  @param xs    the traversable object.
   *  @return      the updated buffer.
   */
  override def ++=(xs: TraversableOnce[A]): this.type = xs match {
    case v: scala.collection.IndexedSeqLike[_, _] =>
      val n = v.length
      ensureSize(size0 + n)
      v.copyToArray(array.asInstanceOf[scala.Array[Any]], size0, n)
      size0 += n
      this
    case _ =>
      super.++=(xs)
  }

  /** Prepends a single element to this buffer and returns
   *  the identity of the buffer. It takes time linear in
   *  the buffer size.
   *
   *  @param elem  the element to prepend.
   *  @return      the updated buffer.
   */
  def +=:(elem: A): this.type = {
    ensureSize(size0 + 1)
    copy(0, 1, size0)
    array(0) = elem.asInstanceOf[AnyRef]
    size0 += 1
    this
  }

  /** Prepends a number of elements provided by a traversable object.
   *  The identity of the buffer is returned.
   *
   *  @param xs    the traversable object.
   *  @return      the updated buffer.
   */
  override def ++=:(xs: TraversableOnce[A]): this.type = { insertAll(0, xs.toTraversable); this }

  /** Inserts new elements at the index `n`. Opposed to method
   *  `update`, this method will not replace an element with a new
   *  one. Instead, it will insert a new element at index `n`.
   *
   *  @param n     the index where a new element will be inserted.
   *  @param seq   the traversable object providing all elements to insert.
   *  @throws IndexOutOfBoundsException if `n` is out of bounds.
   */
  def insertAll(n: Int, seq: Traversable[A]) {
    if (n < 0 || n > size0) throw new IndexOutOfBoundsException(n.toString)
    val len = seq.size
    val newSize = size0 + len
    ensureSize(newSize)

    copy(n, n + len, size0 - n)
    seq.copyToArray(array.asInstanceOf[Array[Any]], n)
    size0 = newSize
  }

  /** Removes the element on a given index position. It takes time linear in
   *  the buffer size.
   *
   *  @param n       the index which refers to the first element to remove.
   *  @param count   the number of elements to remove.
   *  @throws   IndexOutOfBoundsException if the index `n` is not in the valid range
   *            `0 <= n <= length - count` (with `count > 0`).
   *  @throws   IllegalArgumentException if `count < 0`.
   */
  override def remove(n: Int, count: Int) {
    if (count < 0) throw new IllegalArgumentException("removing negative number of elements: " + count.toString)
    else if (count == 0) return  // Did nothing
    if (n < 0 || n > size0 - count) throw new IndexOutOfBoundsException("at " + n.toString + " deleting " + count.toString)
    copy(n + count, n, size0 - (n + count))
    reduceToSize(size0 - count)
  }

  /** Removes the element at a given index position.
   *
   *  @param n  the index which refers to the element to delete.
   *  @return   the element that was formerly at position `n`.
   */
  def remove(n: Int): A = {
    val result = apply(n)
    remove(n, 1)
    result
  }

  def result: ArrayBuffer[A] = this

  /** Defines the prefix of the string representation.
   */
  override def stringPrefix: String = "ArrayBuffer"

}

/** Factory object for the `ArrayBuffer` class.
 *
 *  $factoryInfo
 *  @define coll array buffer
 *  @define Coll `ArrayBuffer`
 */
object ArrayBuffer extends SeqFactory[ArrayBuffer] {
  /** $genericCanBuildFromInfo */
  implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, ArrayBuffer[A]] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]]
  def newBuilder[A]: Builder[A, ArrayBuffer[A]] = new ArrayBuffer[A]
}