1. Introduction to Computer Science / Procedural – 67130
Unit 10
One Dimensional Arrays

2. Arrays An array is a sequence of variables of identical type
It is used to store large amounts of data, without having to declare many individual variables
[0]
[1]
[2]
[3]
[4]
[5]
[6]
counts

3. Arrays “Arrays bring to data what loops bring to action—power.”
Arrays give us a way of defining a structured collection of data, without having to name each component (as we would have to do with individual variables)
It gives us an important tool for implementing data abstraction

4. Old Example
public static void main (String[ ] args) { int score; int sumOfScores = 0; int numberOfScores = 0;
System.out.print("Enter score (eof ends the data): "); score = SimpleInput.in.readInt( ); int maxOfScores = score; int minOfScores = score; while ( !SimpleInput.in.eof( ) ) { numberOfScores++; //new score sumOfScores += score; //update sum if (maxOfScores < score) //new largest score maxOfScores = score; if (minOfScores > score) //new smallest score minOfScores = score; …

5. That was a “stream-oriented” approach to data
Once a value goes past, it’s gone—there’s only one variable, score, that holds input data.
But suppose we want to read and average the input stream, and echo only values that are above average. We could:
Read the input stream twice, averaging the first time, printing large numbers the second (a file-oriented approach; not practical for human input)
Read and store the input values, summing them as they’re stored. Get average at end, then echo only the larger ones (this will use an array)

6. An array lets us reinspect any part of the data stream
Variables and Arrays 95
264 3
score
sumOfScores
numberOfScores
Simple variables give us a snapshot of the data.
[0]
[1]
[2]
[3]
[4]
[5]
[6]
An array lets us reinspect any part of the data stream
counts

7. A Random Access Data Structure
Arrays are a random access data structure.
Values can be stored or retrieved in any order we want.
[0]
[1]
[2]
[3]
[4]
[5]
[6]
counts

8. Things to Notice with an Array
1. What’s the array’s name?
2. What kinds of values can it hold?
3. How many values can it hold?
4. How do we refer to individual values in the array?
We’ll now look at each of these answers for a Java array

9. Arrays Are a Special Kind of Object
An array contains a fixed number of variables of identical type
This fixed number is called the array’s length
Like any object, an array must first be declared, then allocated (created)
Remember that an array is an object, and this fact will help you

10. Declaring an Array Variable
Declare a variable to be an array: int[ ] counts; double[ ] scores; Time[ ] appointmentTimes;
The brackets tell Java that the variable (counts, scores, or appointmentTimes) will be an array

11. Answers to some questions
We’ve answered questions 1 and 2 with our declarations: 1. What is the array’s name? 2. What kinds of values can it hold? int[ ] counts; double[ ] scores; Time[ ] appointmentTimes;
First array’s name is “counts”, and it holds values of type int, etc.

12. Allocating (creating) an Array in the Heap
We create an array using the new notation, but with some variations
We have to tell new how many variables will be in the array object (use square brackets): counts = new int[10]; scores = new double[15]; appointmentTimes = new Time[10];
In general, new type[ size ] creates an array of length size with variables of type type, returning an array object (in the heap); Answer to Question 3. How many values can it hold? (given during allocation)

13. Doing it All At Once
Obviously, like with any variable (simple or object), you can write it on one line: int[ ] counts = new int[10]; double[ ] scores = new double[15]; Time[ ] appointmentTimes = new Time[10];
Now we have array objects sitting in the heap, called counts (that can hold 10 ints), scores (that can hold 15 doubles), and appointmentTimes (that can hold 10 Time objects)

14. Creation of an Array Object
new type[ size ]
size can be any integer or integer expression: int i = 3; char[ ] name = new char[i]; is just as good as: char[ ] name = new char[3];
The memory in an array is automatically initialized for us (to 0 for numbers, false for booleans, or null for objects, as appropriate)

15. Let’s Look at counts Place to hold 10 ints
[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
counts
Place to hold 10 ints
Each int is held in a separate box
The subscript, or index, of the variables runs from 0 to 9 (the index always starts at 0)
Arrays can contain any type of value: simple value or (reference to) object
Let’s deconstruct Time[ ] appointmentTimes = new Time[10];

16. If We Just Wrote: Time[ ] appointmentTimes;
null
heap
appointmentTimes

17. If We Wrote: Time[ ] appointmentTimes = new Time[10];
null
null
null
null
null
null
null
null
null
null
heap
appointmentTimes

18. After we fill up the appointmentTimes array with Time objects…

19. Answer to Question 4: How do we refer to individual values in the array?
[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
counts
Use subscripts to obtain any specific variable counts[0] is the first variable in counts counts[1] is the second variable in counts counts[9] is the last variable in counts counts[10] is an error!

20. They are Used Like Regular Variables
counts[0] counts[1] counts[9]
These are all int variables, and can be used anywhere any int variable (like “score” or “sumOfScores”) is used: counts[1] = 17; score = counts[8]; sumOfScores = (7 * ((counts[4] + 2)/8));

21. Java Checks Array Bounds For You
counts[10]
This does not exist, since the 10 elements in counts run from 0 to 9
If you try and use this nonexistent value, Java throws an ArrayIndexOutOfBoundsException error
More about these kinds of errors (exceptions) later

22. Of course we can do this with a loop
public class Simple { public static void main (String[ ] args) { int[ ] counts = new int[10]; System.out.println("Enter ten numbers: "); counts[0] = SimpleInput.in.readInt( ); counts[1] = SimpleInput.in.readInt( ); counts[2] = SimpleInput.in.readInt( ); counts[3] = SimpleInput.in.readInt( ); counts[4] = SimpleInput.in.readInt( ); counts[5] = SimpleInput.in.readInt( ); counts[6] = SimpleInput.in.readInt( ); counts[7] = SimpleInput.in.readInt( ); counts[8] = SimpleInput.in.readInt( ); counts[9] = SimpleInput.in.readInt( ); System.out.print(counts[9]+ " " + counts[8] + " " + counts[7] + " " + counts[6] + " " + counts[5] + " " + counts[4] + " " + counts[3] + " " + counts[2] + " " + counts[1] + " " + counts[0] + "\n"); } }
Of course we can do this with a loop

23. A Small Note on Variable Scope
When we write for (int i = 0; i < 10; i++) System.out.println( counts[i] ); the variable i exists only for the scope of the for loop
It cannot be reused later, unless it is redeclared
This is just a convenience for writing loops

24. import intro2cs.utils.*; import java.io.*;
public class Simple { public static void main (String[ ] args) throws IOException { int[ ] counts = new int[10]; System.out.println("Enter ten numbers: "); for (int i = 0; i < 10; i++) { counts[i] = SimpleInput.in.readInt( ); } for (int i = 9; i >= 0; i--) { System.out.print(counts[i] + " "); }
System.out.println(); } }

25. Using a Variable as an Index
If i is an integer variable, you can, for example, write counts[i] to refer to one of the variables in counts
counts[2*i] refers to counts[0] if i is 0, counts[2] if i is 1, etc.; illegal if i is outside the 0 to 4 range
counts[i/2] refers to counts[0] if i is 0 or 1, counts[1] if i is 2 or 3, etc.; illegal if i is outside 0 to 19

26. Alternative Way to Declare and Allocate an Array All At Once
Arrays can be initialized by giving a list of all their elements: int[ ] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
The declaration is on the left side of the assignment
No explicit creation of the object is necessary; Java handles it automatically
It must be done in a single line; this is illegal: int[ ] primes; primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};

27. Let’s Use the Technique
Method that takes an integer and prints out that day of the week:
final String[ ] NAME = {"", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; void printName (int day) { System.out.print(NAME[day]); }

28. What is the Effect of the Following?
int[ ] a, b; a = new int[10]; b = a;
Since arrays are objects, a and b are references to objects (in the heap, as expected)
So now a and b refer to the same array
An array is a mutable object; changes made to the array are reflected in “both” a and b

29. Two Variables Pointing to Same Array Object
int[ ] a, b;
null b
null
heap a

30. Two Variables Pointing to Same Array Object
int[ ] a, b; a = new int[10];
null b
heap a

31. Two Variables Pointing to Same Array Object
int[ ] a, b; a = new int[10]; b = a; b
heap a

32. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; }
a is an array object variable. b receives a copy of a (that is, the address in a is copied to b), and thus points to the same object. Changes to b are reflected in a. firstMethod( ) therefore returns 5.

33. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; }
heap a

34. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; } 9
heap a

35. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; } 9
heap a

36. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; } 9 b
heap a

37. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; } 5 b
heap a

38. Passing an Array as an Argument Between Methods
public int firstMethod( ) { int[ ] a = new int[10]; a[0] = 9; secondMethod(a); return a[0]; } public void secondMethod(int[ ] b) { b[0] = 5; } 5
heap a

39. The public Instance Variable “length”
Every array object has a public instance variable (final) called length
It tells how many elements are in the array
Since it is public, it can be freely accessed; if a is an array, a.length says how many elements it has
Print all elements of the array counts:
for (int i = 0; i < counts.length; i++) System.out.println( counts[i] );

40. Simple Array Processing Loops
Copy all the elements from array b into array a (assume they are same length): for (int i = 0; i < a.length; i++) a[i] = b[i];
How does this differ from a = b;

41. Another Example
Initialize the array counts to contain the numbers 0, 10, 20, etc. up to 90:
counts 10 20 30 40 50 60 70 80 90
[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
for (int i = 0; i < counts.length; i++) counts[i] = i * 10;

42. Read 10 numbers into array “counts” and print them in reverse order (again)
import intro2cs.utils.*; import java.io.*;
public class Simple { public static void main (String[ ] args) throws IOException { int[ ] counts = new int[10]; System.out.println("Enter ten numbers: "); for (int i = 0; i < 10; i++) { counts[i] = SimpleInput.in.readInt( ); } for (int i = 0; i < 10; i++) { System.out.print(counts[9 - i] + " "); }
System.out.println(); } }

43. Another Way to Do It (again)
import intro2cs.utils.*; import java.io.*;
public class Simple { public static void main (String[ ] args) throws IOException { int[ ] counts = new int[10]; System.out.println("Enter ten numbers: "); for (int i = 0; i < 10; i++) { counts[i] = SimpleInput.in.readInt( ); } for (int i = 9; i >= 0; i--) { System.out.print(counts[i] + " "); }
System.out.println(); } }

44. An Array’s Size is Fixed When Created
An array cannot grow
Its size is determined when it is created
One simple way of dealing with this is to make a large array and only partially fill it
Let’s look at an example

45. Encapsulate reading and echoing an array in a class
We’ll make a class Collection, which will include an array and methods for handling the array
The client uses Collection by creating a Collection object, passing its constructor the (large) size of the array desired
Let’s look at how the client would use the Collection class, and how the class itself is defined

46. The client to the Collection class
class MyClient { static final int INPUT_MAX = 1000; public static void main (String[ ] arg) { Collection c = new Collection(INPUT_MAX); c.readAndEcho( ); } }

47. A wrapper class for an array
class Collection { private int[ ] _item; private int _size = 0; public Collection (int number) { _item = new int[number]; } public void readAndEcho( ) { System.out.println("Enter first number: "); int n = SimpleInput.in.readInt( ); while ( !SimpleInput.in.eof( ) ) { _item[_size] = n; _size++; System.out.println("Enter next number: "); n = SimpleInput.in.readInt( ); } System.out.println( ); for (int i = 0; i < _size; i++) System.out.println(_item[i]); } }
A wrapper class
for an array

48. What That Looks Like in Memory
array of ints
Attributes: _item = … _size = … Methods: void readAndEcho ( )
Collection object c
heap

49. Another Example
Create program that reads in student name and two scores and prints average for each student (until end-of-file): Enter name and two exam grades: Bill Enter name and two exam grades: Scott Enter name and two exam grades: ^D or ^Z

50. The Expected Output The client program: Name Average Bill 63 Scott 90
class MyClient { static final int INPUT_MAX = 100; public static void main (String[ ] arg) { GradeBook grades = new GradeBook(INPUT_MAX); grades.readAndAverage( ); } }

51. A wrapper class for 3 arrays
class GradeBook { private String[ ] _names; private int[ ] _exam1, _exam2; private int _size = 0; public GradeBook (int number) { _names = new String[number]; _exam1 = new int[number]; _exam2 = new int[number]; } public void readAndAverage( ) { while ( true ) { System.out.println("Enter name and " "two exam grades: "); _names[_size] = SimpleInput.in.readString(); if (SimpleInput.in.eof( ) ) break; _exam1[_size] = SimpleInput.in.readInt( ); _exam2[_size] = SimpleInput.in.readInt( ); _size++; } System.out.println( ); System.out.println("\tName\tAverage"); for (int i = 0; i < _size; i++) System.out.println("\t" + _names[i] "\t\t" + (_exam1[i] + _exam2[i]) / 2); } }
A wrapper class
for 3 arrays

52. What That Looks Like in Memory
Three arrays: one of Strings,
two of ints
GradeBook object
grades
heap

53. Arrays Can Contain Objects
Arrays can contain any kind of data, not just integers and strings
So instead of building GradeBook the way we did, let’s create a Student class, and fill up the array with Student objects
Each object includes names and grades

54. Class Student, for making Student Objects
class Student { private String _name; private int _exam1, _exam2; public Student ( ) { } public void setName (String s) { _name = s; } public void setExam1 (int n) { _exam1 = n; } public void setExam2 (int n) { _exam2 = n; } public String getName ( ) { return _name; } public int getExam1 ( ) { return _exam1; } public int getExam2 ( ) { return _exam2; } public int getAvg ( ) {return (_exam1+_exam2)/2; } } }
can be omitted; Java will provide a default constructor that does nothing if we left this out

55. A wrapper class for an array of objects
class GradeBook { private Student[ ] _students; private int _size = 0; public GradeBook (int number) { _students = new Student[number]; } public void readAndAverage( ) { String nextname; while ( true ) { System.out.println("Enter name and two exam grades: "); nextname = SimpleInput.in.readString( ); if ( SimpleInput.in.eof( ) ) break; _students[_size] = new Student( ); _students[_size].setName(nextname); _students[_size].setExam1(SimpleInput.in.readInt( )); _students[_size].setExam2(SimpleInput.in.readInt( )); _size++; } System.out.println( ); System.out.println("\tName\tAverage"); for (int i = 0; i < _size; i++) System.out.println( "\t" _students[i].getName( ) + "\t\t" _students[i].getAvg( ) ); } }
A wrapper class
for an array of objects

56. What That Looks Like in Memory
Student objects
GradeBook object
grades
heap

57. Now I Want an Iterator for my Collection (from Aviv's post)
An iterator is a simple object that allows access in sequence to the elements stored in some data structure
Iterators are (supposed to be) "lightweight" objects: they do not hold a copy of the data they are iterating over, but instead just point to some place within the data structure
The underlying representation of the data is hidden from the user

58. New Class, GradeBookIterator, for making GradeBook Iterators
class GradeBookIterator { private int _position; ... // other instance variable(s) public GradeBookIterator (GradeBook mine) { }
public boolean hasNext ( ) { }
public Student next ( ) {
... } }

59. next( ) and hasNext( )
The method next( ) of the iterator does two things:
It returns the current element in the particular GradeBook that the iterator is connected to
Sets the iterator to point to the next element
hasNext( ) returns false when you have run out of elements; another call to next( ) would result in an error

60. How Do We Create an Iterator that is Connected to a Particular GradeBook? (one way)
Add a getIterator( ) method to the GradeBook class
This method will call the GradeBookIterator's constructor, giving it the necessary argument: new GradeBookIterator(...)
And of course return to the client the address of this new GradeBookIterator object

61. A wrapper class for an array of objects
class GradeBook { private Student[ ] _students; private int _size = 0; public GradeBook (int number) { _students = new Student[number]; } public void readAndAverage( ) { }
public GradeBookIterator getIterator( ) {
... } }
A wrapper class
for an array of objects

62. Now the Client can use the Iterator to "walk through" the data, not knowing the underlying representation
The client program:
class MyClient { static final int INPUT_MAX = 100; public static void main (String[ ] arg) { GradeBook grades = new GradeBook(INPUT_MAX); grades.readAndAverage( ); GradeBookIterator gradesItr = grades.getIterator(); while (gradesItr.hasNext( )) { Student current = gradesItr.next( ); // Do something with current object
} } }

63. What That Looks Like in Memory
Student objects
GradeBookIterator object
GradeBook object
gradesItr
heap
grades