Arrays
Chapter 8
Spring 2006
CS 101
Aaron Bloomfield
1
Introduction to arrays
2
Background
 Programmer often need the ability to represent a group of
values as a list
 List may be one-dimensional or multidimensional
 Java provides arrays and the collection classes
 The Vector class is an example of a collection class
 Consider arrays first
3
Example
 Definitions
char[] c;
int[] value = new int[10];
 Causes
 Array object variable c is un-initialized
 Array object variable value references a new ten element
list of integers
 Each of the integers is default initialized to 0
c
value
0
0
0
0
…
0
4
An array example
int[] v = new int[10];
int i = 7;
int j = 2;
int k = 4;
v[0] = 1;
v[i] = 5;
v[j] = v[i] + 3;
v[j+1] = v[i] + v[0];
v[v[j]] = 12;
System.out.println(v[2]);
v[k] = stdin.nextInt();
v
8 is displayed
Suppose
3 is extracted
0
1
0
0
8
0
6
0
3
0
0
0
5
12
0
0
v[0]
v[1]
v[2]
v[3]
v[4]
v[5]
v[6]
v[7]
v[8]
v[9]
5
Array variable definition styles
 Without initialization
ElementType [ ] id;
Brackets
Name of
Type of
list
values in indicate array
variable being
list
defined
int [] a;
int a[];
6
Array variable definition styles
 With initialization
Nonnegative integer expression specifying the
number of elements in the array
ElementType [ ] id = new ElementType [n];
A new array of n
elements
7
Where we’ve seen arrays
 public static void main (String[] args)
 Thus, the main() method takes in a String array as the
parameter
 Note that you can also define it as:
 public static void main (String args[])
 or
 public static void main (String[] foobar)
8
Basic terminology
 List is composed of elements
 Elements in a list have a common name
 Example: a[3] = 5;
 The common name is ‘a’
 The list as a whole is referenced through the common name
 List elements are of the same type — the base type
 Elements of a list are referenced by subscripting (indexing) the
common name
9
Java array features
 Subscripts are denoted as expressions within brackets: [ ]
 Base (element) type can be any type
 Size of array can be specified at run time
 This is different that pure C! (for the most part, at least)
 Index type is integer and the index range must be 0 ... n-1
 Where n is the number of elements
 Just like Strings indexing!
 Automatic bounds checking
 Ensures any reference to an array element is valid
 Data field length specifies the number of elements in the list
 Array is an object
 Has features common to all other objects
 More on this later…
10
Consider
 Segment
int[] b = new int[100];
b[-1] = 0;
b[100] = 0;
 Causes
 Array variable to reference a new list of 100 integers
 Each element is initialized to 0
 Two exceptions to be thrown
 -1 is not a valid index – too small
 100 is not a valid index – too large
 IndexOutOfBoundsException
11
Consider
Point[] p = new Point[3];
p[0] = new Point(0, 0);
p[1] = new Point(1, 1);
p[2] = new Point(2, 2);
p[0].setX(1);
p[1].setY(p[2].getY());
Point vertex = new Point(4,4);
p[1] = p[0];
vertex
p[2] = vertex;
p
p[0]
p[1]
p[2]
null
null
null
Point: (1,
(0, 0)
Point: (4, 4)
Point: (1, 2)
1)
Point: (2, 2)
12
New 2005 demotivatiors!
13
Explicit initialization
 Syntax
id references an array of n elements. id[0] has
value exp0, id[1] has value exp1, and so on.
ElementType []
id = {
exp0 , exp1 , ... expn-1 } ;
Each expi is an expression that
evaluates to type ElementType
15
Explicit initialization
 Example
String[] puppy = { “pika”, “mila”, “arlo”,
“nikki” };
int[] unit = { 1 };
 Equivalent to
String[] puppy = new String[4];
puppy[0] = “pika";
puppy[1] = “mila";
puppy[2] = “arlo";
puppy[3] = “nikki";
int[] unit = new int[1];
unit[0] = 1;
16
Array members
 Member length
 Size of the array
for (int i = 0; i < puppy.length; ++i) {
System.out.println(puppy[i]);
}
17
Array members
 Member clone()
 Produces a shallow copy
Point[] u = { new Point(0, 0), new Point(1, 1)};
Point[] v = u.clone();
v[1] = new Point(4, 30);
u[0]
u[1]
u
Point: (0, 0)
v
Point: (1, 1)
Point: (4, 30)
18
v[0]
v[1]
Array members
 Member clone()
 Produces a shallow copy
Point[] u = { new Point(0, 0), new Point(1, 1)};
Point[] v = u.clone();
v[1].setX(10);
u[0]
u[1]
u
Point: (0, 0)
(1, 1)1)
Point: (10,
v
19
v[0]
v[1]
Making a deep copy
 We want to copy the array and all the objects each element
of the array references
 This is called a deep copy
 Example
Point[] w = new Point[u.length];
for (int i = 0; i < u.length; ++i) {
w[i] = (Point) u[i].clone();
}
20
Making a deep copy
u[0]
u[1]
u[2]
u
Point: (0, 0)
w[0]
w[1]
Point: (2, 1)
Point: (2, 2)
Point: (2, 1)
Point: (2, 2)
w[2]
w
Point: (0, 0)
21
Review of arrays
 Creating an array:
int[] foo = new int[10];
 Accessing an array:
foo[3] = 7;
System.out.print (foo[1]);
 Creating an array:
String[] bar = new String[10];
 Accessing an array:
bar[3] = “qux”;
System.out.println (bar[1]);
22
How Java represents arrays
 Consider
int[] a = { 1, 2, 3, 4, 5 };
Array
- length = 5
a
- data =
1
1
2
2
3
4
3
5
4
5
+…
23
More about how Java represents Arrays
 Consider
int[] a;
int[] b = null;
int[] c = new int[5];
int[] d = { 1, 2, 3, 4, 5 };
a = c;
d = c;
a
-
b
null
c
0
0
0
0
0
d
1
2
3
4
5
24
What do these pictures mean?













Light beer
Dandy lions
Assaulted
peanut
Eggplant
Dr. Pepper
Pool table
Tap dancers
Card shark
King of pop
I Pod
Gator aide
Knight mare
Hole milk
25
ArrayTools
26
ArrayTools.java
 We want to create a series of general utility methods to be
used for arrays
 We will put these into an ArrayTools class
27
ArrayTools.java – outline
public class ArrayTools {
// class constant
private static final int MAX_LIST_SIZE = 1000;
// sequentialSearch(): examine unsorted list for key
public static int sequentialSearch(int[] data, int key) { ...
// putList (): prints list to screen
public static void putList(int[] data) { ...
// getList(): extract and return up to MAX_LIST_SIZE values
public static int[] getList() { ...
// reverse(): reverses the order of the element values
public static void reverse(int[] list) { ...
// binarySearch(): examine sorted list for a key
public static int binarySearch(char[] data, char key) { ...
}
28
ArrayTools.java method putList()
 To print the array:
public static void putList(int[] data) {
for (int i = 0; i < data.length; ++i) {
System.out.println(data[i]);
}
}
 Consider
int[] score = { 6, 9, 82, 11, 29, 85, 11, 28, 91 };
putList(score);
29
ArrayTools.java method getList()
public static int[] getList() {
Scanner stdin = new Scanner (System.in);
int[] buffer = new int[MAX_LIST_SIZE];
int listSize = 0;
for (int i = 0; (i < MAX_LIST_SIZE) &&
stdin.hasNext(); ++i) {
buffer[i] = stdin.nextInt();
++listSize;
}
int[] data = new int[listSize];
for (int i = 0; i < listSize; ++i) {
data[i] = buffer[i];
}
return data;
}
30
ArrayTools.java method reverse()
public static void reverse(int[] data) {
int[] clone = data.clone();
for ( int i = 0; i < clone.length; ++i ) {
data[i] = clone[clone.length-1-i];
}
}
 Consider
int[] foo = { 1, 2, 3, 4, 5 };
reverse (foo);
putList (foo);
31
Demo.java
public class Demo {
// main(): application entry point
public static void main(String[] args) {
System.out.println ("");
System.out.println ("Enter list of integers:");
int[] numbers = ArrayTools.getList ();
System.out.println ("");
System.out.println ("Your list");
ArrayTools.putList (numbers);
ArrayTools.reverse
System.out.println
System.out.println
ArrayTools.putList
System.out.println
(numbers);
("");
("Your list in reverse");
(numbers);
();
}
}
32
ArrayTools demo…

ArrayDemo.java
34
… main (String args[])
36
Consider that main() method again
 public static void main (String args[])
 How does one pass in a parameter to the main method?
public class MainParameters {
public static void main (String args[]) {
System.out.println ("Number of paramters to “ +
"main(): " + args.length);
if ( args.length > 0 ) {
for ( int i = 0; i < args.length; i++ )
System.out.println ("parameter " +
i + ": '" + args[i] + "'");
}
}
37
}
Program Demo

MainParameters.java


Via JCreator
Via the command line
38
Basic array searching
39
Searching for a value
System.out.println("Enter search value (number): ");
int key = stdin.nextInt();
int i;
for (i
i = 0
0; i < data.length
data.length; ++i
++i) {
if (key == data[i]) {
break;
}
}
0
1
2
data
4
9
5
key
5
i
0
1
2
if (i != data.length) {
System.out.println(key + " is the " + i
+ "-th element");
}
else {
System.out.println(key + " is not in the list");40
}
Searching for the minimum value
 Segment
int minimumSoFar = sample[0];
for (int i = 1; i < sample.length; ++i) {
if (sample[i] < minimumSoFar) {
minimumSoFar = sample[i];
}
}
41
ArrayTools.java method sequentialSearch()
public static int sequentialSearch(int[] data, int key) {
for (int i = 0; i < data.length; ++i) {
if (data[i] == key) {
return i;
}
}
key
11
return -1;
}
data
0
1
2
3
4
5
6
7
8
6
9
82
11
29
85
11
29
91
 Consider
int[] score = { 6, 9, 82, 11, 29, 85, 11, 28, 91 };
int i1 = sequentialSearch(score, 11);
42
int i2 = sequentialSearch(score, 30);
Today’s demotivators
43
Sorting
44
Sorting
 Problem
 Arranging elements so that they are ordered according to
some desired scheme
 Standard is non-decreasing order
 Why don't we say increasing order?
 Major tasks
 Comparisons of elements
 Updates or element movement
45
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 0
 Swaps smallest element with v[0]
 This results in smallest element being in the correct place
for a sorted result
v
0
1
2
3
4
5
6
‘Q'
'E'
'W'
‘E'
'Q'
'R'
'T'
'Y'
'U'
7
'I'
8
9
'O'
'P'
46
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 1
 Swaps second smallest element with v[1]
 This results in second smallest element being in the
correct place for a sorted result
v
0
1
2
3
4
5
6
7
8
9
'E'
'W'
'I'
'Q'
'R'
'T'
'Y'
'U'
'I'
'W'
'O'
'P'
47
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 2
 Swaps third smallest element with v[2]
 This results in third smallest element being in the correct
place for a sorted result
0
v
'E'
1
'I'
2
3
4
5
6
7
8
9
'Q'
‘O'
'R'
'T'
'Y'
'U'
'W'
'O'
‘Q'
'P'
48
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 3
 Swaps fourth smallest element with v[3]
 This results in fourth smallest element being in the correct
place for a sorted result
0
v
'E'
1
'I'
2
3
4
5
6
7
8
9
‘O'
'R'
‘P'
'T'
'Y'
'U'
'W'
‘Q'
'P'
‘R'
49
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 4
 Swaps fifth smallest element with v[4]
 This results in fifth smallest element being in the correct
place for a sorted result
0
v
'E'
1
'I'
2
3
4
5
6
7
8
9
‘O'
‘P'
'T'
‘Q'
'Y'
'U'
'W'
‘Q'
‘T'
‘R'
50
ArrayTools.java selection sorting
public static void selectionSort(int[] v) {
for (int i = 0; i < v.length-1; ++i) {
// find the location of the ith smallest element
int spot = i;
for (int j = i+1; j < v.length; ++j) {
if (v[j] < v[spot]) { // is current location ok?
// update spot to index of smaller element
spot = j;
}
}
// spot is now correct, so swap elements
int rmbr = v[i];
v[i] = v[spot];
v[spot] = rmbr;
}
}
51
Iteration i
// find the location of the ith smallest element
int spot = i;
for (int j = i+1; j < v.length; ++j) {
if (v[j] < v[spot]) // is spot ok?
// update spot with index of smaller element
spot = j;
}
// spot is now correct, swap elements v[spot] and v[i]
52
From Dubai
53
Binary search
54
Binary search
 Given a list, find a specific element in the list
 List MUST be sorted!
 Each time it iterates through, it cuts the search
space in half
 A binary search is MUCH faster than a sequential
search
55
Binary search use
The ‘BS’ in BSDemo is for Binary Search, mind you

public class BSDemo {
public static void main(String[] args) {
int[] numbers = { 9, 3, 1, 8, 4, 6, 10, 2 };
System.out.println ("The original list of numbers:");
ArrayTools.putList(numbers);
System.out.println();
ArrayTools.selectionSort(numbers);
System.out.println ("The sorted list of numbers:");
ArrayTools.putList(numbers);
System.out.println();
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
("Searching
("Searching
("Searching
("Searching
("Searching
("Searching
("Searching
for
for
for
for
for
for
for
0: " + ArrayTools.binarySearch(numbers, 0));
1: " + ArrayTools.binarySearch(numbers, 1));
4: " + ArrayTools.binarySearch(numbers, 4));
5: " + ArrayTools.binarySearch(numbers, 5));
6: " + ArrayTools.binarySearch(numbers, 6));
10: " + ArrayTools.binarySearch(numbers, 10));
11: " + ArrayTools.binarySearch(numbers, 11));
}
}
56
Binary search use demo…

BSDemo.java
57
Chapter 2: Computer bugs
58
Binary search
public static int binarySearch (int[] data, int key) {
int i = 0;
// left endpoint of search interval
int j = data.length-1; // right endpoint of search interval
while ( i < j ) {
int m = (i+j)/2;
if ( key > data[m] ) {
i = m+1;
} else {
j = m;
}
}
if ( key == data[i] ) {
return i;
} else {
return -1;
}
59
}
Binary search, take 1
public static int binarySearch (int[] data, int key) {
int i = 0;
int j = data.length-1;
data
i
while ( i < j ) {
int m = (i+j)/2;
if ( key > data[m] ) {
i = m+1;
} else {
j = m;
}
}
if ( key == data[i] ) {
return i;
} else {
return -1;
}
key
returns:
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
2
4
6
8
10
12
14
16
18
20
0
5
6
m
4
7
6
5
j
9
7
6
14
6
60
Binary search
 But what if the element is not in the list?
61
Binary search, take 2
public static int binarySearch (int[] data, int key) {
int i = 0;
int j = data.length-1;
data
i
while ( i < j ) {
int m = (i+j)/2;
if ( key > data[m] ) {
i = m+1;
} else {
j = m;
}
}
if ( key == data[i] ) {
return i;
} else {
return -1;
}
key
returns:
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
2
4
6
8
10
12
14
16
18
20
0
5
7
m
4
7
6
j
9
7
15
-1
62
Binary search
 A somewhat alternative view of what a binary search does…
63
How long does a binary search take?
 Given a array of 64 elements
 1st iteration cuts the array to 32
 2nd iteration cuts the array to 16
 3rd to 8
 4th to 4
 5th to 2
 6th to 1
 Given a array of 1024 elements
 1st iteration cuts the array to 512
 ...
 10th iteration cuts the list to 1 element
 Thus, the binary search takes log2 n iterations!
 Where n is the size of the array
64
Binary search vs. sequential search
 Assume the array has n elements
 Sequential search takes n iterations to find the element
 Binary search takes log2 n iterations to find the element
 Consider a list of 1 million elements
 Binary search takes about 20 iterations
 Sequential search takes 1,000,000 iterations
 Consider a list of 1 trillion elements
 Binary search takes about 40 iterations
 Sequential search takes 1,000,000,000,000 iterations
65
Multi-dimensional arrays
67
Multidimensional arrays
 Many problems require information be organized as a twodimensional or multidimensional list
 Examples
 Matrices
 Graphical animation
 Economic forecast models
 Map representation
 Time studies of population change
 Microprocessor design
68
Example
 Segment
int[][] m = new int[3][];
m[0] = new int[4];
m[1] = new int[4];
m[2] = new int[4];
 Produces
m[0]
m
m[1]
m[2]
m[2][0]
m
0
m[0][0]
0
m[0][1]
When an array is
created, each
value is initialized!
0
m[0][2]
0
m[0][3]
m[2][1]
m[2][2]
m[2][3]
0
0
0
0
0
0
0
0
m[1][0]
m[1][1]
m[1][2]
m[1][3]
69
Example
 Alternative
int[][] m = new int[3][4];
 Produces
m[0]
m[1]
m[2]
m[2][0]
m
0
m[0][0]
0
m[0][1]
0
m[0][2]
0
m[0][3]
m[2][1]
m[2][2]
m[2][3]
0
0
0
0
0
0
0
0
m[1][0]
m[1][1]
m[1][2]
m[1][3]
70
Multidimensional array visualization
 A multi-dimensional array declaration (either one):
int[][] m = new int[3][4];
 How we visualize it:
0
0
0
0
0
0
0
0
0
0
0
0
or
0
0
0
0
0
0
0
0
0
0
0
0
71
Example
 Segment
for (int c = 0; c < m.length; ++c) {
for (int r = 0; r < m[c].length; ++r) {
System.out.print("Enter a value: ");
m[c][r] = stdin.nextInt();
}
}
0
0
0
0
0
0
0
0
0
0
0
0
72
Rows by columns or columns by rows?
 Consider int[][] m = new int[3][4];
 Is that 3 rows by 4 columns or 3 columns by 4 rows?
0
0
0
0
0
0
0
0
0
0
0
0
or
0
0
0
0
0
0
0
0
0
0
0
0
 The answer is that it can be either
 As long as you are consistent with your column/row
73
placement
Rows by columns or columns by rows?
 This makes it 3 columns by 4 rows:
for (int c = 0; c < m.length; ++c)
for (int r = 0; r < m[c].length; ++r) {
System.out.print("Enter a value: ");
m[c][r] = stdin.nextInt();
}
 This makes it 3 rows by 4 columns:
for (int c = 0; c < m.length; ++c)
for (int r = 0; r < m[c].length; ++r) {
System.out.print("Enter a value: ");
m[r][c] = stdin.nextInt();
}
74
Example
 Segment
String[][]
s[0] = new
s[1] = new
s[2] = new
s[3] = new
 Produces
s[0]
s = new String[4][];
String[2];
String[2];
String[4];
String[3];
s[1]
s[2]
s[3]
null
null null
s[3][0] s[3][1] s[3][2]
s
null
null null
null
s[2][0] s[2][1] s[2][2] s[2][3]
null null
s[0][0] s[0][1]
null
null
75
s[1][0] s[1][1]
Multidimensional array visualization
 Segment
String[][]
s[0] = new
s[1] = new
s[2] = new
s[3] = new
 Produces
s = new String[4][];
String[2];
String[2];
String[4];
String[3];
0
0
0
0
0
0
0
0
0
0
or
0
0
0
0
0
0
0
0
0
0
0
 Called a “ragged”
array
0
76
Explicit Initialization
 Segment
int c[][] = {{1, 2}, {3, 4}, {5, 6}, {7, 8, 9}};
 Produces
c[0]
c[1]
c[2]
7
c[3]
8
9
c[3][0] c[3][1] c[3][2]
c
5
6
c[2][0] c[2][1]
1
2
c[0][0] c[0][1]
3
4
c[1][0] c[1][1]
77
Matrices
 A two-dimensional array is sometimes known as a matrix
because it resembles that mathematical concept
 A matrix a with m rows and n columns is represented
mathematically in the following manner
a1  1 a 1 2  a 1 n
a2  1 a 2 2  a 2 n


am  1 a m 2  a m n
78
Matrix addition
 Definition C = A + B
 cij = aij + bij
 cij is sum of the elements in the same row and column of
A and B
79
Matrix addition
public static double[][] add(double[][] a, double[][] b) {
// determine number of rows in solution
int m = a.length;
// determine number of columns in solution
int n = a[0].length;
// create the array to hold the sum
double[][] c = new double[m][n];
// compute the matrix sum row by row
for (int i = 0; i < m; ++i) {
// produce the current row
for (int j = 0; j < n; ++j) {
c[i][j] = a[i][j] + b[i][j];
}
}
return c;
}
80
Homework J8
 You will be creating a Universe class
 The Universe class contains a 2-D array
 In each spot will be a Location object
 (from a previous HW)
 Lab 10 is going to be a Map class
 Will print out the 2-D Universe via text
81
Alien Song

AlienSong.mpg
82
Vector class
This is also the review
for the third midterm
83
Limitations of arrays
 You can’t change their size once created
 This can be a big problem!
 So



we will create a new class that will operate like an array:
We can store and get elements by index number
It will automatically increase in size as needed
And other fancy features…
 Let’s call the class Vector
 As we are basically writing the java.util.Vector class
84
Properties of our Vector class
 It needs to have an array to hold the values
 As our internal array will often be bigger than the number of
elements in the Vector, we need a size as well
 More on what this means in a slide or two…
 Not much else…
85
Methods in our Vector class




Insert and remove elements into the Vector
Get an element from the Vector
Find the length
Print it out to the screen
 What happens when the array field is full, and we want to add
an element?
 We will need to increase the size of the array
 So we need a method to do that as well
86
Our first take on our Vector class
public class Vector {
private Object array[];
private int size = 0;
Vector() {
array = new Object[100];
}
Vector(int length) {
array = new Object[length];
}
}

What does this mean?
 We’ll see that a bit later…
 But briefly, it means the array can store any object
87
Adding an element to our Vector
public void add (Object o) {
array[size++] = o;
}
 Pretty easy!
 But what if the array is full?
 We need a way to increase the capacity of the array
88
Increasing the Vector’s array’s capacity
private void increaseCapacity() {
int oldSize = array.length;
Object newArray[] = new Object[2*oldSize];
for ( int i = 0; i < oldSize; i++ )
newArray[i] = array[i];
array = newArray;
}

And our new add() method:
public void add (Object o) {
if ( size == array.length )
increaseCapacity();
array[size++] = o;
}
89
Methods can be private as well
 Notice that the increaseCapacity() method is called only by
the add() method when necessary
 It’s not ever going to be called by whomever is using our
Vector
 Thus, we will make it private
 That means that only other Vector methods can call it
90
Removing an element from a Vector
public Object remove (int which) {
Object ret = array[which];
for ( int i = which; i < array.length-1; i++ )
array[i] = array[i+1];
array[array.length-1] = null;
size--;
return ret;
}
91
Miscellaneous other methods
public int size() {
return size;
}
public Object get (int which) {
return array[which];
}
92
Our toString() method
public String toString() {
String ret = "[";
for ( int i = 0; i < size; i++ ) {
ret += array[i];
if ( i != size-1 )
ret += ", ";
}
ret += "]";
return ret;
}
93
Using our Vector

This code is in a separate class called VectorUsage
public static void main (String[] args) {
Vector v = new Vector();
for ( int i = 12; i < 30; i++ ) {
v.add (String.valueOf(i));
}
System.out.println (v);
System.out.println (v.size());
String s = (String) v.get(5);
System.out.println (s);
v.remove (5);
System.out.println (v);
v.remove (5);
System.out.println (v);
}
94
Program Demo

VectorUsage.java
95
The “real” Vector class
 Java provides a Vector class
 In java.util
 It contains all of the methods shown
96
Program Demo

VectorUsage.java

But using java.util.Vector
97
What about those errors?
 When compiled with java.util.Vector, we see:
 Note: C:\...\VectorUsage.java uses unchecked or
unsafe operations.
 Note:
Recompile
with
-Xlint:unchecked
for
details.
 You can ignore these
 They deal with generics, which you will see in future
courses
 The program was still compiled
98
More on using the Vector class
 To add a Location object l to the end of a Vector v
 v.add(l);
 To get the Location object at the end of the Vector v
 Location l = (Location) v.get(v.size()-1);
 To remove a Location object from the end of a Vector v
 Location l = (Location) v.remove(v.size()-1);
 This both removes the object from the Vector and stores
the removed value into l
99
Very unofficial demotivators
100
Wrapper classes
102
But what about adding variables?
 The add method takes an Object as a parameter
 public void add (Object o) {
 Although we haven’t seen it yet, this means you can add
any object you want to the vector
 Primitive types (i.e. variables) are not objects
 How can they be added?
 The solution: wrapper classes!
103
The Integer wrapper class
 This is how you add an int variable to a Vector:
int x = 5;
Integer i = new Integer(x);
vector.add (i);
//…
Integer j = (Integer) v.get(0);
int y = j.intValue();
 Pretty annoying syntax – we’ll see how to get around it in a
bit…
104
More on wrapper classes
 All the primitive types have wrapper classes
 Usually, the names are just the capitalized version of the
type
 I.e. Double for double, Byte for byte, etc.
 Two exceptions: int and char
 int has Integer
 char has Character
105
More on wrapper classes
 Consider this code:
int x = 5;
vector.add (x);
//…
int y = vector.get(0);
 Does this code work?
 It shouldn’t
 As we are adding a variable (not an object) to a vector
 But it does work!
 Why?
106
Auto-boxing
 Java 1.5 will automatically “wrap” a primitive value into it’s
wrapper class when needed
 And automatically “unwrap” a wrapper object into the
primitive value
 So Java translates the previous code into the following:
int x = 5;
vector.add (new Integer(x));
//…
int y = ((Integer)vector.get(0)).intValue();
 This is called autoboxing
 And auto-unboxing (unauto-boxing?)
 This does not work in Java 1.4 or before
107
More on auto-boxing
 Consider the following code:
Double d = 7.5;
Double e = 6.5;
Double f = d + e;
System.println (f);
 This is doing a lot of auto-boxing (and auto-unboxing):
Double d = new Double(7.5);
Double e = new Double(6.5);
Double f = newDouble(d.doubleValue() +
e.doubleValue());
System.println (f);
108
A solution to commenting your
code

The commentator:
http://www.cenqua.com/commentator/
109