Lecture 17 Instructor: Craig Duckett Passing & Returning Arrays.

BIT115:Introduction to Programming

Lecture 17Instructor: Craig Duckett

Passing & Returning Arrays

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

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

And now ...

The Quiz

Recap: ArraysWhat 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.

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

Recap: ArraysWe 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

Recap: Arrays


The entire collection of element identifiers is called the index


Each individual element identifier in the index is called a subscript

Recap: Arrays

grades = new int[5];


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

Recap: ArraysBecause 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

Arrays as Parameters

Arrays as Parametersclass ArrayHelper - PrintArray method

main - shortArray - longArray


Passing anarray as a parameter


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!


Is allocated whenprogram loads;

“temporary”

Is allocated whenprogram runs;“persistent”

Don’t worry about any of this memory, stack, or heap information as it won’t show up on the Final Exam


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.

Arrays as Parametersimport 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

Lecture 18: Returning an ArrayI’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.

Passing and Returning ArraysPassing Arrays as ArgumentsArrays 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

Passing and Returning ArraysIn 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.java

double is the return type

return sends back a double

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

Assignment 4 AdvancedA 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.

ICE: Arrays as Parameters

ICE_18_PrintArray.java

I’m going to walk-through the buildingof the PrintArray method for ICE PART 1

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

import java.util.*;


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


import java.util.*;


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


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


// print out both the short and long arrays System.out.println("\nThe Short Array: "); arrayTester.PrintArray(shortArray); // Passing the shortArray to the PrintArray() method


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


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

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

Lecture 17 Instructor: Craig Duckett Passing & Returning Arrays.

Documents

Transcript of Lecture 17 Instructor: Craig Duckett Passing & Returning Arrays.