Transcript Chapter 1

Chapter 9: Arrays
Java Programming:
From Problem Analysis to Program Design,
Second Edition
Chapter Objectives
 Learn about arrays.
 Explore how to declare and manipulate data into
arrays.
 Understand the meaning of “array index out of
bounds.”
 Become familiar with the restrictions on array
processing.
2
Chapter Objectives
 Discover how to pass an array as a parameter to a
method.
 Discover how to manipulate data in a twodimensional array.
 Learn about multidimensional arrays.
3
Enter 5 numbers:
Motivation
3 6 8 9 0
Sumtheir
= 26
Write a program to read 5 numbers, find
sum and print them in reverse order.
Numbers is reverse = 0 9 8 6 3
import java.util.*;
public class RevOrder{
static Scanner console = new Scanner(System.in);
public static void main(String[] args){
int item0, item1, item2, item3, item4;
int sum;
System.out.println("Enter 5 numbers: ");
item0=console.nextInt();
item1=console.nextInt();
item2=console.nextInt();
item3=console.nextInt();
item4=console.nextInt();
sum = item0+item1+item2+item3+item4;
System.out.println("Sum = " + sum);
System.out.print("Numbers is reverse = ");
System.out.println(item4+" "+item3+" "+item2+" "+item1+" "+item0);
}
}
4
Motivation
Write a program to read 100 numbers, find
their sum and print them in reverse
order
?????
5
Motivation
 Note the following in the preceding program:
 5 variables must be declared.
 All variables are of type int.
 Variables name (item0  item4);
 Instead of having to use a large number of
individual and unconnected variables, we can use
a single data structure that combines them.
6
Motivation
 In this chapter, we will examine:
 How to store collections of items and access
these items using one variable name given to
the collection.
 The data structure that lets you do all of theses
things in java is called array.
7
Array
 A structured data type with a fixed number of
components.
 Every component is of the same type.
 Components are accessed using their relative
positions in the array.
8
One-Dimensional Arrays
 Syntax to declare an array:
dataType[ ] arrayName;
 In java, an array is an object:
 It is a reference variable.
 To store data we must instantiate the array object
using new operator.
 Syntax to instantiate an array object:
arrayName = new dataType[intExp]
Where intExp = number of components in array >= 0
9
One-Dimensional Arrays
 Declaration with instantiation:
dataType[ ] arrayName = new dataType[intExp]
 Declaring more than one array of the same type:
dataType[ ] arrayName1, arrayName2;
 Syntax to access an array component:
 arrayName[indexExp]
 intExp = number of components in array >= 0
 0 <= indexExp < intExp
10
Array num
Example9-1
 The statement:
int[] num = new int[5];
 Declares and creates the array num of 5 components.
 Each component is of type int.
 The components are accessed as:
num[0], num[1],num[2],num[3],num[4]
11
Array num
int[] num = new int[5];
Why all the values = 0 ???????????
12
Array num
 When an array is instantiated. Java
automatically initializes its components to
their default values. For example, numeric
arrays are initialized to 0.
 What are string, char array initialized to?
13
Alternate Ways to Declare an array
 int list[]; // here [] is after list not int
 But take care, what is the difference here:
 int alpha[], beta;
 int[] gamma, delta;
 It is recommended that you declare arrays as int[].
14
Array list
int [] list = new int[10];
15
Array list
16
Specifying Array Size
During Program Execution
int arraySize;
System.out.print("Enter the size of the array: ");
arraySize = console.nextInt();
System.out.println();
int[] list = new int[arraySize];
 Arrays that are created during program execution are
called dynamic arrays.
17
Array Initialization During Declaration
double[] sales = {12.25, 32.50, 16.90, 23, 45.68};
 The values, called initial values, are placed between braces and
separated by commas.
 Here,
sales[0]= 12.25, sales[1]= 32.50, sales[2]= 16.90,
sales[3]= 23.00, and sales[4]= 45.68.
 When declaring and initializing arrays, the size of the array is
determined by the number of initial values within the braces.
 If an array is declared and initialized simultaneously, we do not
use the operator new to instantiate the array object.
18
Arrays and the Instance Variable length
 A public instance variable length is associated with each
array that has been instantiated.
 The variable length contains the size of the array.
 The variable length can be directly accessed in a program
using the array name and the dot operator.
 This statement creates the array list of six components and
initializes the components using the values given.
int[] list = {10, 20, 30, 40, 50, 60};
Here, list.length is 6.
19
Arrays and the Instance Variable length
 This statement creates the array numList of 10 components and initializes
each component to 0.
int[] numList = new int[10];
 The value of numList.length is 10.
 These statements store 5, 10, 15, and 20, respectively, in the first four
components of numList.
numList[0]
numList[1]
numList[2]
numList[3]
=
=
=
=
5;
10;
15;
20;
 The value of numList.length is still 10.
 You can store the number of filled elements, that is, the actual number of
elements, in the array in a variable, SAYnoOfElement. It is a common
practice for a program to keep track of the number of filled elements in an
array.
20
Processing One-Dimensional Arrays
 Loops used to step through elements in array and perform operations.
int[] list = new int[100];
int i;
//process list[i], the (i + 1)th element of list
for (i = 0; i < list.length; i++)
//inputting data to list
for (i = 0; i < list.length; i++)
list[i] = console.nextInt();
//outputting data from list
for (i = 0; i < list.length; i++)
System.out.print(list[i] + " ");

Remember to start loop counter from 0 because
Array index starts from 0.
21
Arrays

Some operations on arrays:




Initialize
Input data
Output stored data
Find largest/smallest/sum/average of elements
Example 9_3
double[] sales = new double[10];
int index;
double largestSale, sum, average;
22
Code to Initialize Array to
Specific Value (10.00)
for (index = 0; index < sales.length; index++)
sales[index] = 10.00;
Note: .length NOT .length()
It is a variable not a method.
23
Code to Read Data into Array
for (index = 0; index < sales.length; index++)
sales[index] = console.nextDouble();
24
Code to Print Array
for (index = 0; index < sales.length; index++)
System.out.print(sales[index] + " ");
25
Code to Find Sum and Average of
Array
sum = 0;
for (index = 0; index < sales.length; index++)
sum = sum + sales[index];
if (sales.length != 0)
average = sum / sales.length;
else
average = 0.0;
26
Determining Largest Element in
Array
maxIndex = 0;
for (index = 1; index < sales.length; index++)
if (sales[maxIndex] < sales[index])
maxIndex = index;
largestSale = sales[maxIndex];
27
Determining Largest Element in Array
28
Determining Largest Element in
Array
After for loop executes, maxIndex=7 
largestSale=sales[maxIndex]= 98.23.
Exercises:
 How to find the smallest element in an array????
 Rewrite the program that we discussed in the
beginning of this chapter: the RevOrd class.
29
Array Index Out of Bounds
 An array is in bounds if:
0 <= index <= arraySize – 1
 If index < 0 or index > arraySize-1:
ArrayIndexOutOfBoundsException exception is
thrown. If the program does not handle this exception, the
program terminates.
30
Base address:
 Base address: is the address (memory location) of the first
component in an array.
 Base address of list is the address of list[0].
 Value of variable list is the base address of the array= the
address of list[0].
 When you pass an array as a parameter, the base address of the
actual array is passed to the formal parameter.
31
Declaring Arrays as Formal
Parameters to Methods
General syntax to declare an array as a formal parameter:
dataType[] arrayName
public static void arraysAsFormalParameter(int[] listA,
double[] listB, int num)
{
//...
}
int[] intList = new int[10];
double[] doubleNumList = new double[15];
int number;
arraysAsFormalParameter(intList, doubleNumList, number);
32
The Assignment Operators and Arrays
int listA={5,10,15,20,25,30,35};
int listB=new int[listA.length];
33
The Assignment Operators and Arrays
 You can use the assignment operator(=) to assign
listA to listB. However, the result obtained
might not be what you expect.
 For example: listA = listB;
 You expect: element of listA are copied to
listB.
 That is wrong, listA is a reference variable, both
listA and listB refer to the same array.
34
The Assignment Operators and Arrays
35
The Assignment Operators and Arrays
To copy listA components to listB:
for (int index = 0; index < listA.length; index++)
listB[index] = listA[index];
36
Relational Operators Arrays
if (listA == listB)
...
 The expression listA == listB determines if the values of
listA and listB are the same, thus determining whether
listA and listB refer to the same array.
 To determine whether listA and listB contain the same
elements, you need to compare them component by component.
 You can write a method that returns true if two int arrays
contain the same elements.
37
Relational Operators and Arrays
boolean isEqualArrays(int[] firstArray,
int[] secondArray)
{
if (firstArray.length != secondArray.length)
return false;
for (int index = 0; index < firstArray.length;
index++)
if (firstArray[index] != secondArray[index])
return false;
return true;
}
if (isEqualArrays(listA, listB))
...
38
Methods for Array Processing
Example 9_5
public static void fillArray(int[] list, int noOfElements)
{
int index;
for (index = 0; index < noOfElements;
index++)
list[index] = console.nextInt();
}
39
Methods for Array Processing
public static void printArray(int[] list,
int noOfElements)
{
int index;
for (index = 0; index < noOfElements; index++)
System.out.print(list[index] + " ");
}
public static int sumArray(int[] list,
int noOfElements)
{
int index;
int sum = 0;
for (index = 0; index < noOfElements; index++)
sum = sum + list[index];
return sum;
}
40
Methods for Array Processing
public static int indexLargestElement(int[] list,
int noOfElements)
{
int index;
int maxIndex = 0;
for (index = 1; index < noOfElements; index++)
if (list[maxIndex] < list[index])
maxIndex = index;
return maxIndex;
}
public static void copyArray(int[] list1,
int[] list2,
int noOfElements)
{
int index;
for (index = 0; index < noOfElements; index++)
list2[index] = list1[index];
}
41
Methods for Array Processing
You MUST Check example9_6 for
calling these methods.
42
Parallel Arrays
 Arrays are parallel if the corresponding components hold related information.
 Example:
You need to keep track of 50 students ID with their grades.
int [] studentId = new int[50];
char[] courseGrade = new char[50];
studentId[3] and courseGrade[3] holds the data for the same student.
studentId
2345
4563
4590
2404
courseGrade
A
C
C
B
43
Arrays of Objects
 Can use arrays to manipulate objects.
 Example: Create an array named array1 with N
objects of type T:
T[] array1 = new T[N]
 Can instantiate array1 as follows:
for(int j=0; j <array1.length; j++)
array1[j] = new T();
44
Array of String Objects
String[] nameList = new String[5];
nameList[0]
nameList[1]
nameList[2]
nameList[3]
=
=
=
=
"Amanda Green";
"Vijay Arora";
"Sheila Mann";
"Rohit Sharma";
nameList[4] = "Mandy Johnson";
45
Array of String Objects
46
Array of String Objects
 You can use String methods to work with the
objects of nameList.
 nameList[0].equals(“Amanda Green”)
// true
 nameList[4].substring(0,5)
//Mandy
47
Arrays of Objects of Other Classes
Clock[] arrivalTimeEmp = new Clock[100];
48
Instantiating Array Objects
for (int j = 0; j < arrivalTimeEmp.length; j++)
arrivalTimeEmp[j] = new Clock();
49
Instantiating Array Objects
arrivalTimeEmp[49].setTime(8, 5, 10);
50
Arrays and Variable Length
Parameter List
 The syntax to declare a variable length formal
parameter (list) is:
dataType ... identifier
51
Arrays and Variable Length Parameter List
public static double largest(double ... numList)
{
double max;
int index;
if (numList.length != 0)
{
max = numList[0];
for (index = 1; index < numList.length;
index++)
{
if (max < numList [index])
max = numList [index];
}
return max;
}
return 0.0;
}
52
Arrays and Variable Length Parameter List
double num1 = largest(34, 56);
double num2 = largest(12.56, 84, 92);
double num3 = largest(98.32, 77, 64.67, 56);
System.out.println(largest(22.50, 67.78,
92.58, 45, 34, 56));
double[] numberList = {18. 50, 44, 56.23, 17.89
92.34, 112.0, 77, 11, 22,
86.62);
System.out.println(largest(numberList));
53
Arrays and Variable Length
Parameter List
Rules to follow when using a variable length formal parameter
list:
1. A method can have both a variable length formal parameter
and other formal parameter.
public static void myMethod (String
name, double num, int … intList)
2.
A method can have at most one variable length formal
parameter.
3.
If a method has both a variable length formal parameter and
other formal parameter, then the variable length formal
parameter must be the last).
54
foreach loop
 The most recent version of Java provides a special type of for
loop to process the elements of an objects such as an array.
 The syntax to use this for loop to process the elements of an
array is:
for (dataType identifier : arrayName)
statements
 identifier is a variable, and the data type of
identifier is the same as the data type of the array
components.
 This form of for is called a foreach loop.
55
foreach loop
sum = 0;
for (double num : list)
sum = sum + num;
//line1
//line2
//line3
 The for statement in Line 2 is read for each num in list. The identifier
num is initialized to list[0]. In the next iteration, the value of num is
list[1], and so on.
for (double num : numList)
{
if (max < num)
max = num;
}
56
Two-Dimensional Arrays
inStock
[Red]
[Brown]
[Black]
[White]
[Gray]
[GM]
10
4
95
3
5
[Ford]
6
3
6
6
4
[Toyota]
3
5
3
6
7
[BMW]
8
2
7
5
3
[Nissan]
0
4
5
33
4
[Volvo]
1
5
7
9
7
57
Two-Dimensional Arrays
 Data is sometimes in table form (difficult to represent using a
one-dimensional array).
 To declare/instantiate a two-dimensional array:
dataType[ ][ ] arrayName = new
dataType[intExp1][intExp2];
 To access a component of a two-dimensional array:
arrayName[indexExp1][indexExp2];
 intExp1, intExp2 >= 0
 indexExp1 = row position
 indexExp2 = column position
58
Two-Dimensional Arrays
double[][]sales = new double[10][5];
59
Accessing Two-Dimensional
Array Components
=25.75
60
Two-Dimensional Arrays
int [][] matrix = new int[20][15];
20 rows
15 columns
matrix.length = 20 //number of rows
 Each row of matrix is 1-D array
matrix.[0].length = 15 //# of columns in 1st row
matrix.[1].length = 15 // # of columns in 2nd row
61
Two-Dimensional Arrays:
Special Cases
 Can specify different number of columns for each
row (ragged arrays). In this case, each row must
be instantiated separately.
62
Two-Dimensional Arrays:
Special Cases
To create this array, first we create 1-D array board of 5
rows:
int[] board = new int[5];
board[0]
board[1]
board[2]
board[3]
board[4]
=
=
=
=
=
new
new
new
new
new
int[6];
int[2];
int[2];
int[3];
int[4];
63
Two Dimensional Array Initialization
During Declaration
int[][] board = {{2,3,1} , {15,25,13} , {20, 4, 7}};
board
[0]
[1]
[2]
[0]
2
3
1
[1]
15
25
13
[2]
20
4
7
What is the array created after this statement:
int[][] table = {{2,3,1,5} , {15,25} , {4, 23, 45}};
64
Processing Two Dimensional Array
 Three ways to process two-dimensional arrays:
 Entire array.
 Particular row of array (row processing).
 Particular column of array (column processing).
 Processing algorithms is similar to processing algorithms
of one-dimensional arrays.
 The following declarations are used for our examples:
static final int ROWS=7;
static final int COLUMNS=6;
int[][] matrix = new int [ROWS][COLUMNS];
int row, col, sum, largest, temp;
65
Processing Two Dimensional Array
matrix
[0]
[1]
[2]
[2]
[4]
[5]
[0]
[1]
[2]
[3]
[4]
[5]
[6]
matrix.length =7 // == ROWS
matrix[0].length=matrix[1].length, … , matrix[6].length // == COLUMNS
66
Two-Dimensional Arrays:
Processing
 Loop for processing row 5 elements:
for (col=0; col < matrix[5].length; col++)
//process matrix[5][col]
 Loop for processing column 2 elements:
for (row=0; row < matrix.length; row++)
//process matrix[row][2]
67
Two-Dimensional Arrays: Processing
Initialization
for (row = 0; row < matrix.length; row++)
for (col = 0; col < matrix[row].length;
col++)
matrix[row][col] = 10;
Print
for (row = 0; row < matrix.length; row++)
{
for (col = 0; col < matrix[row].length; col++)
System.out.printf("%7d", matrix[row][col]);
System.out.println();
}
68
Two-Dimensional Arrays: Processing
Input
for (row = 0; row < matrix.length; row++)
for (col = 0; col < matrix[row].length; col++)
matrix[row][col] = console.nextInt();
Sum by Row
for (row = 0; row < matrix.length; row++)
{
sum = 0;
for (col = 0; col < matrix[row].length; col++)
sum = sum + matrix[row][col];
System.out.println("Sum of row " + (row + 1)
+ " = "+ sum);
}
69
Two-Dimensional Arrays: Processing
Sum by Column
for (col = 0; col < matrix[0].length; col++)
{
sum = 0;
for (row = 0; row < matrix.length; row++)
sum = sum + matrix[row][col];
System.out.println("Sum of column " + (col + 1)
+ " = " + sum);
}
70
Two-Dimensional Arrays: Processing
Largest Element in Each Row
for (row = 0; row < matrix.length; row++)
{
largest = matrix[row][0];
for (col = 1; col < matrix[row].length;
col++)
if (largest < matrix[row][col])
largest = matrix[row][col];
System.out.println("The largest element of row "
+ (row + 1) + " = " + largest);
}
71
Two-Dimensional Arrays: Processing
Largest Element in Each Column
for (col = 0; col < matrix[0].length; col++)
{
largest = matrix[0][col];
for (row = 1; row < matrix.length; row++)
if (largest < matrix[row][col])
largest = matrix[row][col];
System.out.println("The largest element of col "
+ (col + 1) + " = " + largest);
}
72
Multidimensional Arrays
 Can define three-dimensional arrays or n-dimensional arrays (n
can be any number).
 Syntax to declare and instantiate array:
dataType[][]…[] arrayName = new
dataType[intExp1][intExp2]…[intExpn];
 Syntax to access component:
arrayName[indexExp1][indexExp2]…[indexExpn]
 intExp1, intExp2, ..., intExpn = positive integers
 indexExp1,indexExp2, ..., indexExpn = non-negative
integers
73
Loops to Process
Multidimensional Arrays
double[][][] carDealers = new double[10][5][7];
for (i = 0; i < 10; i++)
for (j = 0; j < 5; j++)
for (k = 0; k < 7; k++)
carDealers[i][j][k] = 10.00;
74
Programming Example:
Text Processing
 Program: Reads given text; outputs the text as is;
prints number of lines and number of times each
letter appears in text.
 Input: File containing text to be processed.
 Output: File containing text, number of lines,
number of times each letter appears in text.
75
Programming Example Solution:
Text Processing
 An array of 26 representing the letters in the alphabet.
 Three methods:
 copyText
 characterCount
 writeTotal
 Value in appropriate index is incremented using methods
and depends on character read from text.
76
Chapter Summary
 Arrays
 Definition
 Uses
 Different arrays





One-dimensional
Two-dimensional
Multidimensional (n-dimensional)
Arrays of objects
Parallel arrays
77
Chapter Summary
 Declaring arrays
 Instantiating arrays
 Processing arrays
 Entire array
 Row processing
 Column processing
 Common operations and methods performed on arrays
 Manipulating data in arrays
78