Instructor: Craig Duckett
Lecture 17
Passing & Returning Arrays
Announcements
Assignment 3 Revision
Due TONIGHT Wednesday, August 17th
Assignment 4 and Final Exam
Due NEXT Wednesday, August 24th, by midnight
Extra Credit (I’ll go over Extra Credit on Monday, August 22nd )
Due NEXT Wednesday, August 24th, by midnight
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: 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.
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
int
int
int
int
grade1
grade2
grade3
grade4
grade5
=
=
=
=
=
100;
89;
96;
100;
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);
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:
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.
Even though you declared an array with
[5] elements, the “count” of the elements
starts with [0]
grades[0]
grades[1]
grades[2]
grades[3]
grades[4]
=
=
=
=
=
100;
89;
96;
100;
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 };
Recap: Arrays
grades[0]
grades[1]
grades[2]
grades[3]
grades[4]
=
=
=
=
=
100;
89;
96;
100;
98;
The entire collection of element
identifiers is called the index
grades[0]
grades[1]
grades[2]
grades[3]
grades[4]
=
=
=
=
=
100;
89;
96;
100;
98;
Each individual element identifier in
the index is called a subscript
Recap: Arrays
Comparing individual integer declarations to an array of integers:
int
int
int
int
int
grade1
grade2
grade3
grade4
grade5
=
=
=
=
=
100;
89;
96;
100;
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]
grades[1]
grades[2]
grades[3]
grades[4]
=
=
=
=
=
100;
89;
96;
100;
98;
In memory, the
array elements are
mostly stored in
sequential order
System.out.println("The first grade is: " + grade[0]);
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
Arrays as Parameters
shortArray created
longArray created
Passing shortArray by name
Passing longArray by name
Arrays as Parameters
class ArrayHelper
- PrintArray method
main
- shortArray
- longArray
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.
Arrays as Parameters
Arrays as Parameters
Arrays as Parameters
Arrays as Parameters
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!
1, 3, 5
But how does this really
work in memory?
How does the method
actually know which
array to point to and use?
Arrays as Parameters
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”
Arrays as Parameters
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.
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 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!
So, when you pass an array as a parameter, you’re actually passing
the address of where the array data is located, and then that data is
copied to the method’s array space to be used.
AN ABSTRACTION:
How Does This Look In Memory?
AN ABSTRACTION:
How Does This Look In Memory?
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
Lecture 14: Returning an Array
I’m going to go over the Lecture 14 part of this now, and repeat it again
on Wednesday where you will do the ICES for Returning an Array at
that time.
Passing and Returning Arrays
Passing Arrays as Arguments
 Arrays are objects.
 Their references can be passed to methods like any other
object reference variable.
showArray(numbers);
5 10 15 20 25 30 35 40
Address
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 Arrays
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:
double is the return type
public static double[] getArray() // <-- No parameters called
{
double[] array = {1.2, 2.3, 4.5, 6.7, 8.9}
return array;
}
return sends back a double
 The getArray method is a public static method that returns an array of
doubles.
See example: ReturnArray.java
Assignment 4 Basic (Demo)
NOTE: You DO 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 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.
ICE: Arrays as Parameters
I’m going to walk-through the building
of the PrintArray method for ICE PART 1
ICE_18_PrintArray.java
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.*;
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
}
}
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
}
}
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
}
}
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]);
}
count
}
}
public class ICE_18_PrintArray extends Object
{
public static void main(String[] args)
{
ArrayHelper arrayTester = new ArrayHelper();
arrayName
// 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);
shortArray
System.out.println("\nThe Long Array: ");
arrayTester.PrintArray(longArray);
}
}
longArray
1, 3, 5
LECTURE 13:
ICE : Arrays as Parameters
34