1. BIT115: Introduction to Programming
Lecture 17
Instructor: Craig Duckett
Passing & Returning Arrays

2. Assignment Dates (By Due Date)
Assignment 1 (LECTURE 5) GRADED! Section 1: Monday, January 22nd
Assignment 2 (LECTURE 8) GRADED! Section 1: Wednesday, January 31st
Assignment 1 Revision (LECTURE 10) GRADED! Section 1: Wednesday, February 7th
Assignment 2 Revision (LECTURE 12) GRADED! Section 1: Wednesday, February 14th
Assignment 3 (LECTURE 13) GRADED! Section 1: Wednesday, February 21st
Assignment 3 Revision (LECTURE 16) GRADED! Section 1: Monday, March 5th
Assignment 4 (LECTURE 18) NO REVISION! Section 1: Monday, March 12th
The Fickle
Finger of Fate

3. Today’s Topics Arrays (Recap) Arrays as Parameters
Returning an Array (we'll cover again in next class)
Assignment 4 Basic and Advanced Overview
WALK-THROUGH: ICE

4. And now ...
The Quiz

5. RECAP: Arrays

6. Recap: Arrays What is an Array?
Primitive variables are designed to hold only one value at a time.
Arrays allow us to create a collection of like values that are indexed.
An array can store any type of data but only one type of data at a time.
An array is a list of data elements.

7. Recap: Arrays
Let’s pretend we have a list of five (5) grades we’d like to store in memory. We could declare the value for each grade one at a time like this:
int grade1 = 100;
int grade2 = 89;
int grade3 = 96;
int grade4 = 100;
int grade5 = 98;
The five grades are then stored in memory wherever there happens to be room. The “address” in memory where each grade is store is it’s declared name (e.g., grade1) and the data stored there is the integer value itself (e.g., 100). To access each grade number and do something with it (e.g., display it), we’d call up the memory location by its assigned (declared) name:
System.out.println("The first grade is: " + grade1);

8. Recap: Arrays
In memory, the array elements are
mostly stored in sequential order
We could, however, simplify our work by doing the same thing with an array. Instead of declaring each integer one at a time, we could declare the whole shebang at the same time, like so:
Even though you declared an array with [5] elements, the “count” of the elements starts with [0]
grades = new int[5];
Initially, this creates a location in memory to hold the five elements that make up the array, automatically initializing each of those storage spaces to zero. All you have to do now is fill those elements.
grades[0] = 100;
grades[1] = 89;
grades[2] = 96;
grades[3] = 100;
grades[4] = 98;
Of course, you could have also declared and set them up like this all in one step:
int[ ] grades = { 100, 89, 96, 100, 98 };

9. Another way of thinking about it in the abstract …
int [] grades = new int[5]; grades[0] = 100; grades[1] = 89; grades[2] = 96; grades[3] = 100; grades[4] = 98;
The numbers inside the square
braces [ ] are the "slot" numbers
The numbers to the right of
the assignment operator '='
are the data values going into the slots

10. Another way of thinking about it in the abstract …
The numbers inside the square
braces [ ] are the "slot" numbers
The numbers to the right of
the assignment operator '='
are the data values going
into the slots

11. Length (size declarator)
int [] grades = new int[5]; grades[0] = 100; grades[1] = 89; grades[2] = 96; grades[3] = 100; grades[4] = 98;
Length (size declarator)
int [] grades = new int[5]; grades[0] = 100; grades[1] = 89; grades[2] = 96; grades[3] = 100; grades[4] = 98;
int [] grades = new int[5]; grades[0] = 100; grades[1] = 89; grades[2] = 96; grades[3] = 100; grades[4] = 98;
Index
Subscripts

12. Recap: Arrays
Comparing individual integer declarations to an array of integers:
int grade1 = 100;
int grade2 = 89;
int grade3 = 96;
int grade4 = 100;
int grade5 = 98;
In memory, the individual integers are stored wherever there happens to be an available space
System.out.println("The first grade is: " + grade1);
grades = new int[5];
grades[0] = 100;
grades[1] = 89;
grades[2] = 96;
grades[3] = 100;
grades[4] = 98;
In memory, the array elements are
mostly stored in sequential order
System.out.println("The first grade is: " + grade[0]);

13. Recap: Arrays
Because array elements are numbered sequentially, it is a no-brainer to either populate the data in the array, or to call up and access the data in the array using
Loops
Scanner keyboard = new Scanner(System.in); // Original code thanks to Kamran Majidimehr! int counter = 0; int arraylength = 0; System.out.println("How many grades would you like to enter?"); arraylength = keyboard.nextInt(); System.out.println("You have indicated that you'd like to enter "
+ arraylength " grades.\nPlease enter grades now, one at a time."); int countdown = arraylength; double average = 0; double grades[] = new double [arraylength]; while( counter < arraylength ) { grades[counter] = keyboard.nextDouble(); System.out.println("(" + (counter + 1) + ") You entered: " + grades[counter] " [There are " + (countdown - 1) + " grades remaining]"); counter++; countdown--; }
With loops you can either enter data manually when prompted or enter data automatically based on the particular requirements of the data going into the array

14. Arrays as Parameters
PASS

15. Arrays are known as "Reference Types"
Now that we have discussed the syntax for working with arrays, we should examine why array types are known as reference types.
As we discussed earlier in the quarter, all the Java primitive types have well-defined standard sizes, so all primitive values can be stored in a fixed amount of memory (between 1 and 8 bytes, depending on the data type). But array types do not have a standard size, and they often require quite a bit more memory than eight bytes.
For this reason, Java does not work with arrays directly. Instead, it works with references to arrays. Because Java handles arrays by reference, array types are known as reference types. In contrast, Java handles values of the primitive types directly, that is to say by value.
A reference to an array is simply some fixed-size value that refers to the array in some way. When you assign an array to this value, you are actually setting that value to hold a reference to that array. Similarly, when you pass an array to a method, what really happens is that the method is given a reference to the array through which it can work with the array in some way.
Typically, this reference is the memory address at where the array is stored.
Let's have a look at what this all means in the grand scheme of things…

16. ANALOGY: Storefront and Warehouse

17. ANALOGY: Storefront and Warehouse

18. ANALOGY: Storefront and Warehouse
43011
43013
43015
43017
43019
My products are stored
In Warehouse # 43015

19. Arrays as Parameters shortArray created longArray created
Passing shortArray by name
Passing longArray by name

20. Arrays as Parameters class ArrayHelper - PrintArray method main
- shortArray
- longArray

21. Arrays as Parameters Passing an array as a parameter
This method has been setup to expect an array to be passed to it, and will use the array space called arrayName to point to the passed array data when it is.

22. Arrays as Parameters

23. Arrays as Parameters

24. Arrays as Parameters
Name Only
Name Only

25. Arrays as Parameters
Passing an array to a method behaves differently than passing a primitive data type. The array values aren't copied directly to the method, but rather a reference to the address where those values can be found.
1, 3, 5
But how does this really work in memory?
How does the method actually know which array to point to and use?

26. Arrays as Parameters Is allocated when Is allocated when
Don’t worry about any of this memory, stack, or heap information as it won’t show up on the Final Exam 
Is allocated when
program loads; “temporary”
Is allocated when
program runs; “persistent”

27. Arrays as Parameters
shortArray
1, 3, 5
longArray
1, 2, 3, 5, 7
(1) PrintArray method is called and
and checks name in parameter
which is a named storage space
in the memory heap
(2) PrintArray than copies the array by its address and then plugs it through the arrayName placeholder where it might be used by the method.
So, when you pass an array as a parameter, you’re actually passing a copy of the address of where the array data is located. Depending how you set up the method to work with the array, the original array data may or may not be changed. Let's have a look at what this "may or may not" means…

28. AN ABSTRACTION: How Does This Look In Memory?
Before either the shortArray or longArray array is passed by name, the arrayName array set up in the method doesn't have a "working" address or value per se, since it will be initialized from the referenced memory address of the name of the array that it is passed.

29. AN ABSTRACTION: How Does This Look In Memory?
Although the name of the array that is being passed is a "reference" it is still "passing by value" except in this case that value is a copy of the address of the named array.

30. Arrays as Parameters EXAMPLES: PassArrayChangeValues.java
import java.util.*; class Change extends Object { public void AddFives(int arrayName[]) { for(int j = 0; j < arrayName.length; j++) { arrayName[j]+=5; // Same as: arrayName[j] = arrayName[j] + 5; } } } public class PassArrayChangeValues extends Object { public static void main(String[] args) { Change DoIt = new Change(); int [] myArray = new int[5]; myArray[0] = 2; myArray[1] = 4; myArray[2] = 6; myArray[3] = 8; myArray[4] = 10; System.out.println("myArray contains:"); for(int i = 0; i < myArray.length; i++) { System.out.println("Slot " + (i + 1) + " is: " + myArray[i]); } DoIt.AddFives(myArray); System.out.println(); System.out.println("myArray NOW contains:"); for(int i = 0; i < myArray.length; i++) { System.out.println("Slot " + (i + 1) + " is: " + myArray[i]); } } }
EXAMPLES: PassArrayChangeValues.java
ArrayTester.java

31. Returning an Array
I’m going to go over the Lecture 18 part of this now, and repeat it again on Monday where you will do the ICES for Returning an Array at that time.

32. Passing and Returning Arrays
Passing Arrays as Arguments
Arrays are objects.
Their references can be passed to methods like any other object reference variable. 5 10 15 20 25
Address
showArray(numbers); 30 35 40
public static void showArray(int[] array) {
for (int i = 0; i < array.length; i++)
System.out.print(array[i] + " "); }
Example: PassArray.java

33. Passing and Returning Arrays
We just learned how you could pass an array into a method. Now we’re going to take this to the next step to learn how you can return an array from a method.
A method can return a reference to an array. To do so, the return type of the method must be declared properly. For example, look at the following method definition:
public static double[] getArray() // <-- No parameters called {
double[] array = {1.2, 2.3, 4.5, 6.7, 8.9}
return array; }
double is the return type
return sends back a double
The getArray method is a public static method that returns an array of doubles.
See example: ReturnArray.java

34. Assignment 4 Basic and Advanced
BASIC is Robot related and includes a few comments and hints. It will create a Histogram with Things and a print out using asterisks. It does not interact wit a User.
ADVANCED is Non-Robot related and includes hardly any hints. It will create a “Guess a Number” game and interact with a User.

35. Assignment 4 Basic (Demo)
NOTE: You will need to pass an array as a parameter to “solve” Assignment 4 Basic, but you DO NOT need to return an array. After today’s ICE you will have learned everything you need to successfully complete Assignment 4 Basic

36. Assignment 4 Advanced
A look at the Advanced “Guessing Game” assignment…
NOTE: You do NOT need to pass an array as a parameter to “solve” Assignment 4 Advanced, and you DO NOT need to return an array, although you could do it that way if you wanted to. You WILL need to return a Boolean ‘true’ or ‘false’ however in some of your methods as well as return the number guessed to be successful with Assignment 4 Advanced.

37. ICE: Arrays as Parameters
I’m going to walk-through the building
of the PrintArray method for ICE PART 1
ICE_18_PrintArray.java

38. import java.util.*; class ArrayHelper extends Object { public void PrintArray( int[] arrayName) // Whatever array is passed in main will populate arrayName here { // Use a for loop here that checks the count against the length of arrayName, then iterates if less than length // HINT: You might want to check out the SOLUTIONS to previous lecture ICE exercises // for ( ?? ; ?? ; ??) { // print out the array } } } public class ICE_18_PrintArray extends Object { public static void main(String[] args) { ArrayHelper arrayTester = new ArrayHelper(); // We're creating the two arrays in two different ways: // the shortArray has 3 locations and the longArray has 5, but in the longArray // we can shorten the way we assign numbers using the single line "array literal" method int [] shortArray; // Instantiate the shortArray here with 3 slots holding the three numbers: 1, 3, // Add number to slot // Add number to slot // Add number to slot int [] longArray; // fill the longArray as an "array literal" with five numbers: 1, 2, 3, 5, // print out both the short and long arrays System.out.println("\nThe Short Array: "); arrayTester.PrintArray(shortArray); // Passing the shortArray to the PrintArray() method System.out.println("\nThe Long Array: "); arrayTester.PrintArray(longArray); // Passing the longArray to the PrintArray() method } }

39. import java.util.*; class ArrayHelper extends Object { public void PrintArray( int[] arrayName) // Whatever array is passed in main will populate arrayName here { // Use a for loop here that checks the count against the length of arrayName, then iterates if less than length // HINT: You might want to check out the SOLUTIONS to previous lecture ICE exercises // for ( ?? ; ?? ; ??) { // print out the array } } } public class ICE_18_PrintArray extends Object { public static void main(String[] args) { ArrayHelper arrayTester = new ArrayHelper(); // We're creating the two arrays in two different ways: // the shortArray has 3 locations and the longArray has 5, but in the longArray // we can shorten the way we assign numbers using the single line "array literal" method int [] shortArray = new int [3]; // Instantiate the shortArray here with 3 slots holding the three numbers: 1, 3, shortArray[0] = 1;
shortArray[1] = 3;
shortArray[3] = 5; int [] longArray; // fill the longArray as an "array literal" with five numbers: 1, 2, 3, 5, // print out both the short and long arrays System.out.println("\nThe Short Array: "); arrayTester.PrintArray(shortArray); // Passing the shortArray to the PrintArray() method System.out.println("\nThe Long Array: "); arrayTester.PrintArray(longArray); // Passing the longArray to the PrintArray() method } }

40. import java.util.*; class ArrayHelper extends Object { public void PrintArray( int[] arrayName) // Whatever array is passed in main will populate arrayName here { // Use a for loop here that checks the count against the length of arrayName, then iterates if less than length // HINT: You might want to check out the SOLUTIONS to previous lecture ICE exercises // for ( ?? ; ?? ; ??) { // print out the array } } } public class ICE_18_PrintArray extends Object { public static void main(String[] args) { ArrayHelper arrayTester = new ArrayHelper(); // We're creating the two arrays in two different ways: // the shortArray has 3 locations and the longArray has 5, but in the longArray // we can shorten the way we assign numbers using the single line "array literal" method int [] shortArray = new int [3]; // Instantiate the shortArray here with 3 slots holding the three numbers: 1, 3, shortArray[0] = 1;
shortArray[1] = 3;
shortArray[3] = 5; int [] longArray = {1, 2, 3, 5, 7};
// print out both the short and long arrays System.out.println("\nThe Short Array: "); arrayTester.PrintArray(shortArray); // Passing the shortArray to the PrintArray() method System.out.println("\nThe Long Array: "); arrayTester.PrintArray(longArray); // Passing the longArray to the PrintArray() method } }

41. import java.util.*; class ArrayHelper extends Object { public void PrintArray( int[] arrayName) // Whatever array is passed in main will populate arrayName here { // Use a for loop here that checks the count against the length of arrayName, then iterates if less than length // HINT: You might want to check out the SOLUTIONS to previous lecture ICE exercises for( int count = 0; count < arrayName.length; count++) { System.out.println( count + ") Number: " + arrayName[count]); } } } public class ICE_18_PrintArray extends Object { public static void main(String[] args) { ArrayHelper arrayTester = new ArrayHelper(); // We're creating the two arrays in two different ways: // the shortArray has 3 locations and the longArray has 5, but in the longArray // we can shorten the way we assign numbers using the single line "array literal" method int [] shortArray = new int [3]; // Instantiate the shortArray here with 3 slots holding the three numbers: 1, 3, shortArray[0] = 1;
shortArray[1] = 3;
shortArray[3] = 5; int [] longArray = {1, 2, 3, 5, 7};
// print out both the short and long arrays System.out.println("\nThe Short Array: "); arrayTester.PrintArray(shortArray); // Passing the shortArray to the PrintArray() method System.out.println("\nThe Long Array: "); arrayTester.PrintArray(longArray); // Passing the longArray to the PrintArray() method } }

42. count arrayName 1, 3, 5 shortArray longArray
import java.util.*; class ArrayHelper extends Object { public void PrintArray( int[] arrayName) { for( int count = 0; count < arrayName.length; count++) { System.out.println( count + ") Number: " + arrayName[count]); } } } public class ICE_18_PrintArray extends Object { public static void main(String[] args) { ArrayHelper arrayTester = new ArrayHelper(); // We're creating the two arrays in two different ways: // the shortArray has 3 locations and the longArray has 5, but in the longArray // we can shorten the way we assign numbers using the single line "array literal" method int [] shortArray = new int [3]; // Instantiate the shortArray here with 3 slots holding the three numbers: 1, 3, shortArray[0] = 1;
shortArray[1] = 3;
shortArray[3] = 5; int [] longArray = {1, 2, 3, 5, 7};
// print out both the short and long arrays System.out.println("\nThe Short Array: "); arrayTester.PrintArray(shortArray); System.out.println("\nThe Long Array: "); arrayTester.PrintArray(longArray); } }
count
arrayName
1, 3, 5
shortArray
longArray

43. In-Class Exercises: Arrays as Parameters