8. Arrays 8.1 Using Arrays 8.2 Reference versus Value Again 8.3 Passing Array Arguments and...

8. Arrays8.1 Using Arrays

8.2 Reference versus Value Again

8.3 Passing Array Arguments and Returning Arrays

8.4 An Example: Simulating Rolls of the Dice

8.6 Solving Problem with Java: Insertion Sort

Objectives

• Know how to create and use Java arrays• Understand that array variables hold references• Copy arrays and pass array arguments• Implement insertion sort using an array to hold the

data

Arrays

• Arrays are objects that help us to organize large amount of information

• An array is an ordered list of values• The entire array has a single name• Each value has a numeric index• An array of size n is indexed from zero to n-1• For example, an array of size 10 holds values that

are indexed from 0 to 9

Arrays

• A particular value in an array is referenced using the array name followed by the index in brackets

• For example, the expression score[2] refers to the value 94 (which is the 3rd value in the array)

• That expression represents a place to store a single integer, and can be used whenever an integer variable can

• For example, it can be assigned a value, printed, or used in a calculation

Arrays

• An array stores multiple values of the same type• That type can be primitive types or objects• Therefore, we can create an array of integers, or an

arrays of characters, or an array of String objects, etc.

• In Java, the array itself is an object• Therefore, the name of the array is an object

reference variable, and the array itself is instantiated separately

Figure 8.2 The score array

74

38

92

score[0]

score[1]

score[2]

Figure 8.3 Searching using int variables

if (score1 == 90)

System.out.println("It's score1");

else if (score2 == 90)

System.out.println("It's score2");

else if (score3 == 90)

System.out.println("It's score3");

Figure 8.4 Searching using an array

for (int i = 0; i < 3; i++)

if (score[i} == 90)

System.out.println("It's at index " + i);

Figure 8.5 Search any size score array

for (int i = 0; i < score.length; i++)

if (score[i} == 90)

System.out.println("It's at index " + i);

Declaring Arrays

• The scores array could be declared in one of the following two ways:

int[ ] score = new int[10];

int score[ ] = new int[10];

• The first way is preferred• Note that the type of the object does not specify its

size, but each object of that type has a specific size• The type of the variable score is int[ ] (an array of

integer)

Declaring Arrays

• Some more examples :double[ ] price = new double[500];

boolean[ ] flag;

flag = new boolean[20];

Bound Checking

• Each array has a public constant called length that stores the size of the array. It is referenced using the name of the array (just like any other object):

score.length

• Note that length holds the number of elements, not the largest index

Initializer Lists

• An initializer list can be used to instantiate and initialize an array in one step

• The values are delimited by braces and separated by commas

• Exampleschar[ ] vowel = {'a', 'e', 'i', 'o', 'u'};

String[ ] day = {"Sunday", "Monday", "Tuesday",

"Wednesday", "Thursday", "Friday",

"Saturday"};

Initializer Lists

• Note that when an initializer list is used, the new operator is not used

• No size value is specified• The size of the array is determined by the number

of items in the initializer list• An initializer list can only be used in the

declaration of an array

Array Examples

• ReverseArray.java

• ArrayCopy.java

• LetterCount.java (extra)

• Calendar.java (extra)

• Primes.java (extra)

Figure 8.7 Reversing the array of Example 8.1

{56, 91, 22, 87, 49, 89, 65} swap 56 and 65 L R {65, 91, 22, 87, 49, 89, 56} swap 91 and 89 L R  {65, 89, 22, 87, 49, 91, 56} swap 22 and 49 L R {65, 89, 49, 87, 22, 91, 56} reverse completed L R

Figure 8.8 Pseudocose to reverse an array

Initialize the array;

Initialize L to the smallest index;

Initialize R to the largest index;

while (L < R) {

Swap the array elements at positions L and R;

Increment L;

Decrement R;

}

Output the reversed array;

Figure 8.9 Primitive types hold values

80

?

80

80

score temp

int score = 80;

temp = score;

Figure 8.10 Memory usage for score

23 73 92

score

Figure 8.11 Memory usage for an array assignment

a. Before the assignment

b. After the assignment, y = x

1 2 3 4 5

54321x

y

x

y

int[]x={1,2,3,4,5};

int[]y;

y = x

Figure 8.12 Memory usage after the assignment y[2] = -38

1 2 4-38 5x

y

Figure 8.13 Memory usage for anArray

anArray

Figure 8.14 memory allocation using the operator new

andArray

Figure 8.15 Figure 8.15 Memory configuration for anArray

andArray 17 10 22

x

y

14

14

72

72

-8

-8

Figure 8.17 Copying array elements

Figure 8.18 The display method

public static void display(int [] anArray) {

System.out.print9"{");

for (int I = 0; I < anArray.length; i++) {

if (I != 0) System.out.print(anArray[i]);

}

System.out.println("}");

}

Arrays as Method Parameters

• An entire array can be passed to a method as a parameter

• Like any other object, the reference to the array is passed, making the argument and the corresponding parameter aliases of each other

• The method accesses the same array as the invoking method

• Changing an array element in the method changes the original

Arrays as Method Parameters

• An array element can be passed to a method as well, and will follow the parameter passing rules of that element's type

• DisplayArray.java• RepeatReverse.java• Dice.java

40 50 60score

anArray

Figure 8.19 Passing the score reference to the anArray parameter

Figure 8.20 The readIntArray method

public static int[] readIntArray() {

String input = JoptionPane.showInputDialog(“Enter the array size”);

int size = Integer.parseInt(input);

int [] anArray = new int[size];

for (int i=0; i<size; i++){

input = JOptionPane.showInputDialog(“Enter anArray[“+i+”] ”);

anArray[i] = Integer.parseInt(input);

}

return anArray;

}

Figure 8.21 The reverse method

public static void reverse(int[] anArray) {

int temp; // used to store a value during a swap

int left = 0; // index of the left element to swap

int right = anArray.length -1; // index of the right

//element to swap

while (left < right) {

temp = anArray[left];

anArray[left] = anarray[right];

anArray[right] = temp;

right--;

left++;

}

}

score

anArray

60 50 40

left right

Figure 8.22 Reversing the score array

Figure 8.23 Memory configuration after passing x to assign4

27 27

x someNumber

27 4

x someNumber

Figure 8.24 Effect of the assign4 method

1 2 3 4 5 6

1 2 3 4 5 6 7

2 3 4 5 6 7 8

3 4 5 6 7 8 9

4 5 6 7 8 9 10

5 6 7 8 9 10 11

6 7 8 9 10 11 12

Figure 8.25 Outcomes when tossing two dice

Command-Line Arguments

• The signature of the main method indicates that it takes an array of String objects as a parameter

public static void main(String[ ] args)• These values come from command-line arguments

that are provided when the interpreter is invoked• For example, the following invocation of the

interpreter passes an array of three String objects into main:

java DoIt illinois texas california

Command-Line Arguments

• These strings are stored at indexes 0-2 of the parameter

• NameTag.java (extra)

Figure 8.26 The student array

student 52 76 65

98 87 93

43 77 62

72 73 74

Student[0]

Student[1]

Student[2]

Student[3]

Insertion Sort

• The approach:– pick any item and insert it into its proper place in a sorted sublist

– repeat until all items have been inserted

• In more detail:– consider the first item to be a sorted sublist (of one item)

– insert the second item into the sorted sublist, shifting items as necessary to make room to insert the new addition

– insert the third item into the sorted sublist (of two items), shifting as necessary

– repeat until all values are inserted into their proper position

Insertion Sort

• An example:– original: 3 9 6 1 2– insert 9: 3 9 6 1 2– insert 6: 3 6 9 1 2– insert 1: 1 3 6 9 2– insert 2: 1 2 3 6 9

23 42 54 78 26 12 41 64

Figure 8.27 Partially sorted array

Figure 8.28 Insertion Sort: Top-level pseudocode

Get the data to sort;

Display the data to sort;

Insert each item in the correct

position in its predecessors;

Display the sorted data;

Figure 8.29 Refinement: Get the data to sort

Ask if the user wants to enter data;

if (yes) Get data from the user;

else Generate random data;

Figure 8.30 Refinement: Get data from the user

Input the size of the data;

loop

Get the next item;

Figure 8.31 Revised refinement: Get the data to sort

Input the size of the data;

Ask if the user wants to enter the data;

if (yes)

loop

Get the next item;

else

loop

Generate the next random item;

Figure 8.32 Refinement: Insert items

loop, from second item to last

Insert item i in the correct position

in its predecessors;

8.33 Refinement: Insert item i

Find the correct position, say j, for item i;

Move elements at j to i-1 one position to the right;

Insert item i at position j.

Figure 8.34 Refinement: Finding the correct position for item i

j = 0;

while (item i > item j) j++;

Figure 8.35 Refinement: Move elements j to i-l to the right

Save item i;

for (int k = i; k > j; k--)

item[k] = item[k - 1];

Figure 8.36 Pseudocode for insertion sort

Input the size of the data;

Ask if the user wants to enter the data;

if (yes)

loop

Get the next item;

else

loop

Generate the next random item;

Figure 8.36 Pseudocode for insertion sort (continued)

Display the data to sort;

loop, from second item to last {

j = 0;

while (item i > item j) j++;

Save item i;

for (int k = i; k > j; k--)

item[k] = item[k - l];

item[j] = item[i];

}

Display the sorted data;

Insertion Sortingpublic static void insertionSort (int[ ] number)

{ for (int i = 1; i < number.length; i++) { int key = number[i];

// shift larger values to the right

for (int j = i - 1; j >= 0 && number[j] > key; j--)

number[j + 1] = number[j];

number[j+1] = key; } }

Figure 8.37 Rate of growth of insertion sort

1,000 5,000 10,000 15,000 20,000

20,000

15,000

10,000

5,000

Data size

Tim

e (

mill

iseco

nd

s)

100-item[2]

(0,100)

(0,0)

2*width

Figure 8.38 Part of a bar chart

Interfaces• A Java interface is a collection of abstract

methods and constants• An abstract method is a method header without a

method body• An abstract method can be declared using the

modifier abstract, but because all methods in an interface are abstract, it is usually left off

• An interface is used to formally define a set of methods that a class will implement

Interfacespublic interface Doable

{

public void doThis();

public int doThat();

public void doThis2(double value);

public boolean doTheOther(int num);

}

Interfaces• An interface cannot be instantiated• Methods in an interface have public visibility by

default• A class formally implements an interface by

stating so in the class header, and providing implementations for all abstract methods in the interface

Interfacespublic class canDo implements Doable{ public void doThis() { // whatever } public void doThat() { // whatever } // etc.}

Interfaces• A class that implements an interface can

implement other methods as wellSpeaker.java (extra)

Philosopher.java (extra)

Dog.java (extra)

Talking.java (extra)

• A class can implement multiple interfaces• The interfaces are listed in the implements clause,

separated by commas• The class must implement all methods in all

interfaces listed in the header

Generic Sorting• Integers have an inherent order• An order must be defined in a set of objects for

them to be sorted• The Comparable interface contains only the

compareTo abstract method which is used to compare two objects

• We can use the Comparable interface to develop a generic sort for a set of objects

• The String class implements Comparable which gives us the ability to put strings in alphabetical order

Generic Insertion Sorting public static void insertionSort (Comparable[ ] object)

{ for (int i = 1; i < object.length; i++) { Comparable key = object[i];

// shift larger values to the right

for (int j = i - 1; j >= 0 && object[j].compareTo(key) > 0; j--) object [j + 1] = object[j];

object[j+1] = key; } }