JETT Workshop - Object-Oriented Programming

Computer Science (CSCI) Department
College of Engineering, Computer Science, & Technology (ECST)

JETT Workshops
Object-Oriented Programming

Fall 2004

ArrayList & Arrays

(Example code and figures from Computing Concepts with Java Essentials, 3rd edition, by Cay Horstmann.
Visit www.wiley.com/college/horstmann for information on the current edition of this excellent text.)

see the AP CS Reference Materials
ArrayList
- consider this implementation of the Purse class
- Purse doesn't remember individual Coin objects, just the total
- we don't know how many coins the user might want to add
- use ArrayList to store a variable number of objects
  ArrayList coins = new ArrayList();
  coins.add(new Coin(0.1, "dime"));
Retrieving ArrayList Elements

to retrieve list elements, use the get method
index starts at 0
ArrayList stores references to Object, so we must cast to the correct type
Coin c = (Coin)coins.get(0); // gets the first coin
you will get an IndexOutOfBoundsException error if the index is out of range

a common bounds error:

int n = coins.size();
c = (Coin)coins.get(n); // ERROR - legal index values are 0...n-1

sepping through all the elements

for (int i = 0; i < coins.size(); i++)
{
   Coin c = (Coin)coins.get(i);
   //do something with c
}

Adding and Removing Elements

set overwrites an existing value
coins.set(4, aNickel);
add adds a new value before the index
add(i, c);
remove removes an element at an index

uses ArrayList - Purse.java
Linear Search Algorithm

public class Purse 
{ 
   public boolean find(Coin aCoin) 
   { 
      for (int i = 0; i < coins.size(); i++) 
      { 
         Coin c =(Coin)coins.get(i); 
         if (c.equals(aCoin)) return true; //found a match 
      } 
      return false; //no match in the entire array list 
   } 
   ... 
}

Counting

public class Purse 
{ 
   public int count(Coin aCoin) 
   { 
      int matches = 0; 
      for (int i = 0; i < coins.size(); i++) 
      {
         Coin c =(Coin)coins.get(i); 
         if (c.equals(aCoin)) matches++; //found a match 
      } 
      return matches; 
   } 
   ... 
}

Finding Maximum

public class Purse 
{ 
   public Coin getMaximum() 
   { 
      Coin max =(Coin)coins.get(0); 
      for (int i = 1; i < coins.size(); i++) // loop starts at 1
      { 
         Coin c =(Coin)coins.get(i); 
         if (c.getValue()> max.getValue()) max =c; 
      } 
      return max; 
   } 
   ... 
}

all the goodies - Purse.java
Storing Numbers in an Array List

ArrayList stores references to objects

use wrapper classes to store primitive types such as numbers

// wrap the primitive type
Double wrapper = new Double(29.95);

// unwrap the primitive type
double unwrapped = wrapper.doubleValue()

// putting wrapped primitive in an ArrayList
ArrayList data = new ArrayList();
data.add(wrapper);

// getting it back out again
unwrapped = ((Double).data.get(i)).doubleValue();

also have Integer and Boolean wrappers

Arrays

from the AP CS Java Subset
- One-dimensional arrays and two-dimensional rectangular arrays are part of the AP Java subset.
- Both arrays of primitive types (e.g., int[] and arrays of objects (e.g., Student[])are in the subset.
- Initialization of named arrays (int[] a = { 1, 2, 3 };) is part of the AP Java subset.
- Arrays with more than two dimensions (e.g., rubik = new Color[3][3][3]) are not in the subset.
- "Ragged" arrays (e.g., new int[3][]) are not in the subset.
  - In particular, students do not need to know that an int[3][3] really is an "array of arrays" whose rows can be replaced with other int[] arrays.
- However, students are expected to know that a[0].length is the number of columns in a rectangular two-dimensional array a.
- Anonymous arrays (e.g., new int[] { 1, 2, 3 }) are not in the subset.
to construct an array:
new double[10]
to store the array reference in a variable of type double[]
double[] data = new double[10];
arrays have fixed length
arrays have elements of a specific type, not restricted to Object as ArrayList is
use [] to access an element:
data[4] = 29.95;
get array length as data.length. (Not a method!)

Copying Arrays

copying an array reference yields a second reference to the same array

double[] data = new double[10];
// fill array . . .
double[] prices = data;

use clone to make true copy

double[] prices = (double[])data.clone();

Copying Array Elements

System.arraycopy(from, fromStart, to, toStart, count);

Adding and Removing Array Elements

to add an element:

System.arraycopy(data, i, data, i + 1, data.length - i - 1);
data[i] = x;

to remove an element:

System.arraycopy(data, i + 1, data, i, data.length - i - 1);

Partially Filled Arrays

the array length is the maximum number of elements the array can hold
usually, the array is partially filled

we need a companion variable to keep track of the current size

final int DATA_LENGTH = 100;
double[] data = new double[DATA_LENGTH];
int dataSize = 0;

update dataSize as array is filled:
data[dataSize] = x;
dataSize++;

remember to stop at dataSize when looking at array elements:

for (int i = 0; i < dataSize; i++)
   sum = sum + data[i];

be careful not to overfill the array

if (dataSize >= data.length)
   System.out.println("Sorry--array full");

or grow the array:

if (dataSize >= data.length)
{
   double newData = new double[2 * data.length];
   System.arraycopy(data, 0, newData, 0, data.length);
   data = newData;
}

Exercise - implement a Bank class

use the BankAccount project to start
implement a new class Bank
- use ArrayList to keep track of accounts
- implement some methods
  - add new account
  - delete account
  - get balance of account - need ID
  - deposit in account - need ID
  - withdraw - need ID
  - get total funds in bank - all accounts
  - anything else that sounds interesting!
modify AccountTest to test new code
can you diagram this program in UML?