Introduction to arrays. Array Homogeneous collection of components stored in adjacent memory locations –All elements share same data type –Entire collection

Introduction to arrays

Array

• Homogeneous collection of components stored in adjacent memory locations– All elements share same data type– Entire collection identified with single name– Individual elements accessible via indexindex or

subscriptsubscript indicating the element’s position within the collection

• Used to store a relatively large quantity of values of a particular type

Array Basics

• In Java, an array is an indexed collection of data values of the same type.

• Arrays are useful for sorting and manipulating a collection of values.

Example

• Suppose you had to store 20 distinct whole-number values; you now have 2 choices:– Declare 20 distinct int variables, giving each a

unique name– Declare a single int array with the capacity to

hold 20 elements

• Which is preferable? What if the problem involved 200 numbers? 2000? 2,000,000?

Array declaration

• The syntax for array declaration is:data type [ ] identifier;– “data type” is any built-in, library or user-

defined data type (int, double, char, String, etc.)

– “identifier” is a valid Java identifier– Java supports a variation of this syntax, which

is closer to C/C++ syntax:data type identifier[ ];

Array Basics

• In Java, an array is a reference data type.

• We use the new operator to allocate the memory to store the values in an array.

rainfall = new double [12];

//creates an array of size 12.

Array Basics

• An array has a public constant length for the size of an array.

for (i=0; i<rainfall.length; i++){

...

}

• This approach is particularly useful when the size of an array may change, or is not known in advance.

Array Basics

• Do not confuse the length value of an array and the length method of a String object.

• The length is a method for a String object, so we use the syntax for calling a method.

String str = “This is a string”;

int size = str.length();

Array Basics

• An array, on the other hand, is a reference data type, not an object. Therefore, we do not use a method call.

int size = rainfall.length;

Combining declaration & construction

int [] diceCounter = new int[13] ;

char [] upperAlpha = new char[26];

double [] temps = new double[100];

Accessing individual array values

• An element is accessed via its index or subscript; the first element has subscript 0, the second has subscript 1, the third has subscript 2, and so forth up to the last element, which has subscript size-1

• The notation for accessing an element via its subscript is:arrayName[subscript] where – “arrayName” is the array’s identifier– “subscript” is a number between 0 and size-1

Examples

diceValue[12] = 0;

System.out.print(“” + upperAlpha[0]);

temps[7] *= 0.5;• Note: although these examples use literal

values, a subscript can be any integral expression

• It is up to the programmer to ensure that the subscript value is within the bounds of the array – failure to do so will result in a syntax error

13

What values are assigned?float [] temps = float[ 5 ] ; // allocates memory for array

int m ;

for (m = 0; m < 5; m++)

{

temps[ m ] = 100.0 + m 0.2 ;

}

temps[0] temps[1] temps[2] temps[3] temps[4]

7000 7004 7008 7012 7016

? ? ? ? ?

14

Now what values are printed?float [] temps = float[ 5 ] ; // allocates memory for arrayint m ;

. . . . .for (m = 4; m >= 0; m-- ){ System.out.println(“” + temps[ m ]) ;}


7000 7004 7008 7012 7016

100.0 100.2 100.4 100.6 100.8

15

Variable Subscripts

float [] temps = new float[ 5 ] ;//allocates memory for arrayint m = 3 ; . . . . . .

What is temps[ m + 1] ?

What is temps[ m ] + 1 ?


7000 7004 7008 7012 7016

100.0 100.2 100.4 100.6 100.8

Filling an array with initial values

char [] upperAlpha = new char [26];

for (char c = ‘A’; c <= ‘Z’; c++)upperAlpha[c – ‘A’] = c;

Trace:c c – ‘A’ value stored‘A’ 0 ‘A’‘B’ 1 ‘B’‘C’ 2 ‘C’ . . .‘Z’ 25 ‘Z’‘[‘ 26

Initializing at declaration

char [] lowerAlpha = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’};

List all values in a block of code, terminating with a semicolon:

Compiler automatically sizes array to hold the specified data; array will remain this size, even if different data assigned:

for (int x = 0; x < 10; x++)lowerAlpha[x]=‘!’

Array Basics

• Using constants to declare the array sizes does not always lead to efficient use of space.

• Declaration of arrays with constants is called fixed-size array declaration.

• Fixed-size array declaration may pose two problems:– Not enough capacity for the task at hand.– Wasted space.

Array Basics• In Java, we are not limited to fixed-size array declaration.

• The following code prompts the user for the size of an array and declares an array of designated size:

int size;

int[] number;

size= Integer.parseInt(JOptionPane.showInputDialog(null,

“Size of an array:”));

number = new int[size];

Array Basics

• Any valid integer arithmetic expression is allowed for specifying the size of an array:

size = Integer.parseInt(

JOptionPane.showInputDialog(null,””));

number = new int[size*size + 2* size + 5];

Arrays of Objects

• Arrays are not limited to primitive data types.

• We will use the Person class to illustrate this concept.

• An array of objects is declared and created just as an array of primitive data types is.

Person[] person;

person = new Person[20];

Arrays of Objects

• An array of Person objects after the array is created.

Arrays of Objects

• Array elements are initially null.

• Since each array element is an object, each must also be created.

person[0] = new Person( );

Arrays of Objects

• The person array with one Person object added to it.

Arrays of Objects

• To assign data values to this object, we can execute

person[0].setName (“Ms. Latte”);person[0].setAge (20);person[0].setGender (‘F’);

• The syntax here is the one used to call an object’s method; we are using an indexed expression to refer to the object instead of a simple variable.

Arrays of Objects

• The following program illustrates various aspects of array processing:– Creating a new Person array.– Creating a new Person object and assigning values to

it.– Finding the average age of the persons in the array.– Finding the youngest and oldest persons in the array.– Finding a particular person in the array.

Sample Program (part 1)

import javax.swing.*;

public class ProcessPersonArray {

public static void main (String[ ] args) {

Person[ ] person; //declare the person array person = new Person[5]; //and then create it

//----------- Create person Array ------------//

String name, inpStr; int age; char gender;

Sample program (part 2)for (int i = 0; i < person.length; i++) { // read in data values name = JOptionPane.showInputDialog(null, "Enter name:"); age = Integer.parseInt(JOptionPane.showInputDialog(null,

"Enter age:")); inpStr =JOptionPane.showInputDialog(null, "Enter gender:"); gender = inpStr.charAt(0); // create a new Person and assign values person[i] = new Person( ); person[i].setName ( name ); person[i].setAge ( age ); person[i].setGender( gender );}

Sample program (part 3)

//------ Compute Average Age --------------// float sum = 0, averageAge; for (int i = 0; i < person.length; i++) { sum += person[i].getAge(); } averageAge = sum / (float) person.length;

System.out.println("Average age: " + averageAge); System.out.println("\n");

Sample program (part 4)//-- Find the youngest and oldest person ------////-- Approach No. 3: Using person reference ---//

Person youngest, //points to the youngest person oldest; //points to the oldest person

youngest = oldest = person[0];

for (int i = 1; i < person.length; i++) { if ( person[i].getAge() < youngest.getAge() ) { // found a younger person youngest = person[i]; } else if (person[i].getAge() > oldest.getAge() ) { // found an older person oldest = person[i]; }}System.out.println("Oldest : " + oldest.getName() + " is " + oldest.getAge() + "

years old.");


System.out.println("Youngest: " + youngest.getName() + " is " + youngest.getAge() + " years old.");

//----- Search for a particular person ------// String searchName = JOptionPane.showInputDialog(

null, "Name to search:");

int i = 0;

while ( i < person.length && !person[i].getName().equals( searchName ) ) { //still more persons to search

i++; }


if (i == person.length) //not found - unsuccessful search {

System.out.println( searchName + " was not in the array" );}

else / /found - successful search { System.out.println("Found " + searchName + " at position " + i);

}

}

}

Arrays of Objects

• Deleting objects from an array requires us to search for the object to be removed.

• When the object is located, there are two ways to delete the object.

Arrays of Objects

• The first approach is to set the array element to null.

• Because each array element is a reference to an object, setting the element to null accomplishes this task easily.

Deleting an object from an array• Approach 1 deletion: Setting a

reference to null. The array length is 4.

Deleting an object from an array

• Any index position may be set to null, but this approach creates “holes” in the array.

• The second approach to deleting an object will order the elements so the real references occur at the beginning and the null references at the end.

Deleting an object from an array: method 2

• Packing the elements so the real references occur at the beginning and the null references occur at the end.


• We must fill the holes. There are two possible approaches:– If an object at position J is removed (i.e., set to null),

then elements from position J+1 up to the last non-null reference are shifted one position lower. Finally, the last non-null reference is set to null.

– Replace the removed element by the last element in the array.

Deleting an object from an array• Approach 2 deletion: Replace the

removed element with the last element in the array. The array length is 4.


• Note that assigning null to an array element will not erase the object.

• This operation does initiate a chain reaction that will eventually erase the object from memory.

Arrays of Objects

• A single object may have multiple references pointing to it:

Person p1, p2;

p1 = new Person( );

p2 = p1;

Arrays of Objects

• When an object has no references pointing to it, the system will erase the object and make the memory space available again.

• Erasing an object is called deallocation of memory.

• The process of deallocating memory is called garbage collection. Garbage collection is automatically performed in Java.

Documents

Introduction to arrays. Array Homogeneous collection of components stored in adjacent memory locations –All elements share same data type –Entire collection