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

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

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

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; …

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)

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

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

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

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

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

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.

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)

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)

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)

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];

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

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

After we fill up the appointmentTimes array with Time objects…

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!

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));

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

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

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

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(); } }

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

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};

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]); }

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

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

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

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

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.

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

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

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

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

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

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

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] );

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;

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;

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(); } }

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(); } }

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

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

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( ); } }

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

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

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 57 69 Enter name and two exam grades: Scott 94 86 Enter name and two exam grades: ^D or ^Z

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( ); } }

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

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

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

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

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

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

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

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 ( ) { ... } }

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

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

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

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 } } }

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