Goals

Understanding Arrays
- Reference Variables in Memory
- Declaring Arrays
- Initializing Arrays
- Using Arrays

Resources

http://processing.org/learning/basics/array.html
http://processing.org/learning/2darray/

"Stupidity, outrage, vanity, cruelty, iniquity, bad faith, falsehood / we fail to see the whole array when it is facing in the same direction as we." ~ Jean Rostand

Reference Variables in Memory

Before we declare an array, we need to understand the distinction between variables of the primitive type and variables of the reference type.

A variable of the primitive type simply points to a location in memory where a value is stored.

A reference variable points to the location of an object in memory, and that object stores pointers to each piece of information that it contains.

Since an array is an object, the variable for an array is a reference variable. This means that the variable itself does not represent a value, since an array is a collection of values it points to the collection.

We will see how to access the individual values and variables held in the array in the coming sections.

Declaring Arrays

An array is a special datatype. Much like the string an array is a collection of elements. The difference is that an array is a collection of any type of element we specify. Let's take a look at declaring some arrays of different types.

int[] lottoNumbers = new int[5];
Declares an array of integers for lotto numbers with a size of 5.
String[] names = new String[3];
Declares an array of String variables to store names with a size of 3.
boolean[] lights = new boolean[10];
Declares an array of booleans to control lights with a size of 3.

Arrays are zero indexed like strings which means that even though the size or length may be 3 or 5, the actual position of the last element is always size - 1, since the positions start with 0. Arrays must specify their size when being declared, notice how every example states the number of elements they will contain.

Initializing Arrays

An array is useless unless each element is initialized. After declaring an array, we don't have any actual values in the positions in the array. Instead we have a list of empty buckets (no value) and we must initialize each bucket (position) in the array with a value. Let's take a look.

int[] lottoNumbers = new int[5];
The array lottoNumbers at any position has no value. Let's give it some values.
lottoNumbers[0] = 2; initialize position 0 to 2
lottoNumbers[1] = 4; initialize position 1 to 4
lottoNumbers[2] = 8; ...
lottoNumbers[3] = 16; ...
lottoNumbers[4] = 32; ...

Now that the array has been initialized, we can ask some questions about the array.
println( lottoNumbers[3] ); prints 16
Had the array not been initialized we may have printed 0 since java / processing takes care of this for us. In other programming languages, this would result in a major error and some pretty wacky numbers.

Arrays are collections of any type specified when the array is declared.

Every array must specify a size when declared.

Arrays are zero indexed, positions start at 0 and end at size - 1.

Arrays should always be initialized to a starting value before being used within a program.

Using Arrays

Arrays are pretty useful, even better once you have learn loops. The following examples in this module will involve some loops. It is safe to assume for these example that all loops are simply looping over each position in the array.

//Declare our arrays
float[] xPos = new float[10];
float[] yPos = new float[10];
float[] xVel = new float[10];
float[] yVel = new float[10];
void setup() {
  size(400, 400);
  stroke(0, 128);
  strokeWeight(2);
  fill(255, 0, 0, 128);
  //Initialize all array positions with values
  for (int i = 0; i < xPos.length; i++) {
    xPos[i] = random(16, width - 16);
    yPos[i] = random(16, height - 16);
    xVel[i] = random(-2, 2); //A random number between -2 and 2
    yVel[i] = random(-2, 2);
  }
}

void draw() {
  background(255);
  //Loop over all array positions, do some updates, and draw
  for (int i = 0; i < xPos.length; i++) {
    //update position
    xPos[i] += xVel[i];
    yPos[i] += yVel[i];
    //check walls, if we hit them we reverse our velocity ( vel *= -1 )
    if (abs(xPos[i] - width/2) > 200 - 16) {
      xVel[i] *= -1;
    }
    if (abs(yPos[i] - height/2) > 200 - 16) {
      yVel[i] *= -1;
    }
    //draw ellipses
    pushMatrix();
    translate(xPos[i], yPos[i]);
    ellipse(0, 0, 32, 32);
    popMatrix();
  }
}