1. Lecture 17 Instructor: Craig Duckett Passing & Returning Arrays

2. 2 Assignment 3 Revision (LECTURE 16) GRADED! RETURNED! Monday, June 1 Assignment 4 (LECTURE 20) Wednesday, June 10 Assignment 4 Revision (LECTURE 21) Monday, June 15 Assignment Dates DUE ONE WEEK

3. Today’s Topics Arrays (Recap) Arrays as Parameters Returning an Array Assignment 4 Basic and Advanced Overview WALK-THROUGH: ICE 17.1

4. And now... The Quiz

5. 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.

6. Recap: Arrays int grade1 = 100; int grade2 = 89; int grade3 = 96; int grade4 = 100; int grade5 = 98; 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: 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);

7. Recap: Arrays 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: 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 = new int[5]; 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 }; Even though you declared an array with [5] elements, the “count” of the elements starts with [0] In memory, the array elements are mostly stored in sequential order

8. Recap: Arrays grades[0] = 100; grades[1] = 89; grades[2] = 96; grades[3] = 100; grades[4] = 98; The entire collection of element identifiers is called the index grades[0] = 100; grades[1] = 89; grades[2] = 96; grades[3] = 100; grades[4] = 98; Each individual element identifier in the index is called a subscript

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

10. 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 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 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--; } Loops

11. Arrays as Parameters

12. class ArrayHelper - PrintArray method main - shortArray - longArray

13. Arrays as Parameters Passing an array as a parameter

14. Arrays as Parameters

17. But how does this really work in memory? How does the method actually know which array to point to and use? 1, 3, 5 NOTE! Passing an array to a method behaves differently than passing a primitive data type! The array isn’t copied to the method, the method points to the array data!

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

19. Arrays as Parameters 1, 3, 5 1, 2, 3, 5, 7 shortArray longArray (1) PrintArray method is called and and checks name in parameter which is a named storage space in the memory heap (2) PrintArray than takes the array element data as needed and plugs it through the arrayName placeholder into the body of the method where it can do its work on the same array! NOTE: When a primitive data type, e.g. int, is passed to a method, its value is COPIED to the new method variable. For reference data types, a new reference is created, but unlike for primitives, the data that is referenced is NOT copied to a new area of memory. Instead the new reference is set to REFER to the original area of memory storing the data. This is known as passing by reference. As such, when arrays are concerned, simply calling/using an array method can alter/change the data in the original array since they method is pointing to the same memory location as the original array.

20. Arrays as Parameters 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]); } } } PassArrayChangeValues.java

21. Lecture 18: 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.

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

23. Passing and Returning Arrays In Last Wednesday’s Class we learned how you could pass an array into a method. Today 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; } The getArray method is a public static method that returns an array of doubles. See example: ReturnArray.javaReturnArray.java double is the return type return sends back a double

24. 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

25. 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.

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

27. 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, 5 // Add number to slot 0 // Add number to slot 1 // Add number to slot 2 int [] longArray; // fill the longArray as an "array literal" with five numbers: 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 } }

28. 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, 5 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, 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 } }

29. 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, 5 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 } }

30. 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, 5 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 } }

31. 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, 5 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); } } arrayName shortArray longArray count 1, 3, 5

32. ICE: Arrays as Parameters In-Class Exercises: Arrays as Parameters The ICE exercises will go the remainder of class. If you finish early you are either: (a)free to go home for the evening (b)meet with your team members regarding Assignment 4 (c)work on Assignment 4