Digital Games - ArrayLists

ArrayLists

Declaring
Initializing
Adding
Getting
Example

Reading

ArrayList (required)
Learning Processing: Chapter 23 (recommended)

A list is only as strong as its weakest link. [Donald Knuth]

Declaring an ArrayList

An ArrayList is an object like an array. We need to declare a reference variable that will store a reference to our ArrayList object.

ArrayList lottoNumbers;
Declares a reference variable named lottoNumbers of the type ArrayList.

Now that we have a reference variable of the type ArrayList, we can go ahead and create a new ArrayList object and assign it to this variable.

Initializing an ArrayList

We need to create a new ArrayList object and assign it to our reference variable in order to initialize the variable. Essentially, we need our reference variable to point to some ArrayList object instead of pointing at nothing.

lottoNumbers = new ArrayList();
Creates a new ArrayList object and assigns it to the reference variabel lottoNumbers.
ArrayList lottoNumbers = new ArrayList();
Optionally, like our primitive variables or arrays, we can do this in one line.

Adding Elements to an ArrayList

Notice the ArrayList did not specify how many, or what type of data it will hold. This is because an ArrayList is both size and type agnostic, meaning that it doesn't care. These are some of the great advantages an ArrayList has over an array. However with more advantages comes some additional work.

lottoNumbers.add(2);
Adds the literal value 2 to the last position in the ArrayList.
The ArrayList was empty. Now 2 is only element in the list.
lottoNumbers.add(4);
Adds the literal value of 4 to the last position in the ArrayList.
What position is 2 in now?
lottoNumbers.add(8); lottoNumbers -> [ 2, 4, 8 ]
lottoNumbers.add(16); lottoNumbers -> [ 2, 4, 8, 16 ]
lottoNumbers.add(32); lottoNumbers -> [ 2, 4, 8, 16, 32 ]

The only way to add elements to an ArrayList is at the back, or last position. This requires some preparation in a program if the order of elements is important.

The ArrayList add method will always add elements to the end of the ArrayList.

Getting Elements from an ArrayList

Remember how ArrayLists are type agnostic? Well if the ArrayList doesn't care what types of data it contains, how would we go about using that data. Let's take a look at how we get elements out of an ArrayList.

ArrayList stuff = new ArrayList();
stuff.add("one");
stuff.add("two");
stuff.add(3);
stuff.add(4);
So now the ArrayList has four elements, two string literals and two integers.

Let's assume we wanted test the strings for equality. We need some way of getting objects out of the ArrayList and preserving their type. Let's take a look at how this is done.

String firstElement = (String) stuff.get(0);
This will get the first item that was added to the ArrayList and cast it as a String, then assign it to the String variable named firstElement.
String secondElement = (String) stuff.get(1);
Here we've done the same thing with the second element in the ArrayList.
firstElement.equals(secondElement); false
Now that we safely extracted our String elements, cast them as Strings, and assigned them to some variables, we can use the methods of the String datatype to check if they are equal.

There is a large problem though. Say we tried to compare the elements at positions 2 and 3. These are not String literals, they are integers, so our casting to a string will not work. It is this reason that using ArrayLists requires some extra planning on the part of the programmer. You should know what types you have put in each list and how to treat them safely when getting elements back out.

ArrayLists are type agnostic, they are containers without a label.

When getting elements out of an ArrayList you must always cast the element.

Plan ahead what types get added to the ArrayList and how they will be retrieved.

ArrayList particles = new ArrayList();

//a class to describe a particle
class Particle {
  
  //fields
  float xPos, yPos, xVel, yVel;
  //a constructor to initialize the fields above with initial values
  Particle(float xPos, float yPos, float xVel, float yVel) {
    this.xPos = xPos; 
    this.yPos = yPos; 
    this.xVel = xVel; 
    this.yVel = yVel;
  }
  
  //update the state of this particle (movement and collision with walls)
  void update() {
    //update position
    xPos += xVel;
    yPos += yVel;
    //check walls
    if (abs(xPos - width/2) > width/2 - 16) {
      xVel *= -1;
    }
    if (abs(yPos - height/2) > height/2 - 16) {
      yVel *= -1;
    }
  }
  
  //draw the particle
  void draw() {
    pushMatrix();
    translate(xPos, yPos);
    ellipse(0, 0, 32, 32);
    popMatrix();
  }
  
}//Particle class

void setup() {
  size(fullWidth, fullHeight);
  stroke(0, 128);
  strokeWeight(2);
  fill(255, 0, 0, 128);
  //the ArrayList doesn't have a size yet
  //so we have to set how much we will loop literally
  for (int i = 0; i < 100; i++) {
    //make a new Particle object, assign to ref. var. newParticle
    Particle newParticle = new Particle(
    //arguments passed to the constructor set the initial values for a Particle object's fields
    //take a look at the parameters for the constructor in the Particle class
    random(16, width - 16), 
    random(16, height - 16), 
    random(-4, 4), 
    random(-4, 4)
      //end of arguments
    );
    //add the newParticle object to the ArrayList particles
    particles.add(newParticle);
  }
}

void draw() {
  background(255);
  //loop over all elements in the particles ArrayList, 0 - (particles.size() - 1)
  for (int i = 0; i < particles.size(); i++) {
    //get the current ball in the loop, the ball at position i
    //notice how we cast it as type Particle
    //this is so we can have access to the Particle variables (xPos, yPos, ...)
    Particle curParticle = (Particle) particles.get(i);
    //call the update method of the Particle class
    curParticle.update();
    //call the draw method of the Particle class
    curParticle.draw();
  }
}