Chapter 7 - Arrays: 2003 Prentice Hall, Inc. All Rights Reserved

Chapter 7 - Arrays
Outline
7.1 Introduction
7.2 Arrays
7.3 Declaring and Creating Arrays
7.4 Examples Using Arrays
7.5 References and Reference Parameters
7.6 Passing Arrays to Methods
7.7 Sorting Arrays
7.8 Searching Arrays: Linear Search and Binary Search
7.9 Multidimensional Arrays
7.10 (Optional Case Study) Thinking About Objects:
Collaboration Among Objects
 2003 Prentice Hall, Inc. All rights reserved.

7.1 Introduction
• Arrays
– Data structures
– Related data items of same type
– Remain same size once created
• Fixed-length entries

7.2 Arrays
• Array
– Group of variables
• Have same type
– Reference type

c[ 0 ] -45
Name of array
(note that all c[ 1 ] 6
elements of this
array have the c[ 2 ] 0
same name, c)
c[ 3 ] 72
c[ 4 ] 1543
c[ 5 ] -89
c[ 6 ] 0
c[ 7 ] 62
c[ 8 ] -3
c[ 9 ] 1
Index (or subscript) of c[ 10 ] 6453

the element in array c
c[ 11 ] 78
Fig. 7.1 A 12-element array.

7.2 Arrays (cont.)
• Index
– Also called subscript
– Position number in square brackets
– Must be positive integer or integer expression
a = 5;
b = 6;
c[ a + b ] += 2;
• Adds 2 to c[ 11 ]

7.2 Arrays (cont.)
• Examine array c
– c is the array name
– c.length accesses array c’s length
– c has 12 elements ( c[0], c[1], … c[11] )
• The value of c[0] is –45

7.3 Declaring and Creating Arrays
• Declaring and Creating arrays

– Arrays are objects that occupy memory
– Created dynamically with keyword new
int c[] = new int[ 12 ];
– Equivalent to
int c[]; // declare array variable
c = new int[ 12 ]; // create array
• We can create arrays of objects too
String b[] = new String[ 100 ];

7.4 Examples Using Arrays
• Declaring arrays
• Creating arrays
• Initializing arrays
• Manipulating array elements

7.4 Examples Using Arrays (Cont.)
• Creating and initializing an array

– Declare array
– Create array
– Initialize array elements

1 // Fig. 7.2: InitArray.java Outline
2 // Creating an array.
3 import javax.swing.*;
4 InitArray.java
5 public class InitArray { Create 10 ints for array; each
6 Declare array
int isasinitialized
an to 0 by defaultLine 9
7 public static void main( String args[] ) of ints
array
8 { Declare array as an
9 int array[]; // declare reference to an array array of ints
10 array.length returns
11 array = new int[ 10 ]; // create array length of array Line 11
12
13 String output = "Index\tValue\n"; Create 10 ints for
14 array; each int is
15 // append each array element's value to String output initialized to 0 by
16 for ( int counter = 0; counter < array.length; counter++ )
default
17 output += counter + "\t" + array[ counter ] + "\n";
18
19 JTextArea outputArea = new JTextArea(); Line 16
20 outputArea.setText( output ); array.length
21 returns length of
22 JOptionPane.showMessageDialog( null, outputArea,
23 "Initializing an Array of int Values",
array
24 JOptionPane.INFORMATION_MESSAGE );
array[counter] returns int
25 Line 17
associated with index in array
26 System.exit( 0 ); array[counter]
27
returns int associated
28 } // end main
29
with index in array
30 } // end class InitArray
 2003 Prentice Hall, Inc.

All rights reserved.
Outline
InitArray.java
Each int is initialized Each int is

to 0 by default initialized to 0 by
default

• Using an array initializer

– Use initializer list
• Items enclosed in braces ({})
• Items in list separated by commas
int n[] = { 10, 20, 30, 40, 50 };
– Creates a five-element array
– Index values of 0, 1, 2, 3, 4
– Do not need keyword new

2 // Initializing an array with a declaration.
3 import javax.swing.*; Declare array as an
4 array of ints InitArray.java
5 public class InitArray {
6
7 public static void main( String args[] ) Line 11
8 { Compiler uses initializerDeclare
list array as an
9 // array initializer specifies number of elements and to allocate array array of ints
10 // value for each element
11 int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
12
Line 11
13 String output = "Index\tValue\n"; Compiler uses
14 initializer list to
15 // append each array element's value to String output allocate array
18
19 JTextArea outputArea = new JTextArea();
20 outputArea.setText( output );
21
23 "Initializing an Array with a Declaration",
25
26 System.exit( 0 );
27
28 } // end main
29

Outline
InitArray.java
Each array element

Each array element corresponds to
corresponds to element element in initializer
in initializer list list

• Calculating the value to store in each array

element
– Initialize elements of 10-element array to even integers

2 // Initialize array with the even integers from 2 to 20.
Declare array as an
4 array of ints InitArray.java
5 public class InitArray {
6 Line 10
7 public static void main( String args[] ) Create 10 ints for array
Declare array as an
8 {
array of ints
9 final int ARRAY_LENGTH = 10; // constant
10 int array[]; // reference to int array
11 Line 12
12 array = new int[ ARRAY_LENGTH ]; // create array Create 10 ints for
13 array
14 // calculate value for each array element
15 for ( int counter = 0; counter < array.length; counter++ ) Line 16
16 array[ counter ] = 2 + 2 * counter; Use array index to
17
assign array value
18 String output = "Index\tValue\n";
19
22 Use array index to
23 JTextArea outputArea = new JTextArea(); assign array value
25

26 JOptionPane.showMessageDialog( null, outputArea, Outline
27 "Initializing to Even Numbers from 2 to 20",
29 InitArray.java
31
32 } // end main
33

• Summing the elements of an array

– Array elements can represent a series of values
• We can sum these values

1 // Fig. 7.5: SumArray.java Outline
2 // Total the values of the elements of an array.
3 import javax.swing.*; Declare array with
4
initializer list SumArray.java
5 public class SumArray {
6 Line 9
7 public static void main( String args[] ) Declare array with
8 {
initializer list
9 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
10 int total = 0;
11 Lines 13-14
12 // add each element's value to total Sum all array values
14 total += array[ counter ];
15 Sum all array values
16 JOptionPane.showMessageDialog( null,
17 "Total of array elements: " + total,
18 "Sum the Elements of an Array",
20
22
23 } // end main
24
25 } // end class SumArray

• Using histograms do display array data graphically

– Histogram
• Plot each numeric value as bar of asterisks (*)

1 // Fig. 7.6: Histogram.java Outline
2 // Histogram printing program.
3 import javax.swing.*; Declare array with
4 initializer list Histogram.java
5 public class Histogram {
6
8 { Declare array with
9 int array[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; initializer list
10
11 String output = "Element\tValue\tHistogram";
12
Line 19
13 // for each array element, output a bar in histogram For each array
14 for ( int counter = 0; counter < array.length; counter++ ) { element, print
15 output += "\n" + counter + "\t" + array[ counter ] + "\t"; associated number of
16
asterisks
17 // print bar of asterisks
18 for ( int stars = 0; stars < array[ counter ]; stars++ )
19 output += "*";
20
21 } // end outer for
For each array element, print
22 associated number of asterisks
25

27 "Histogram Printing Program", JOptionPane.INFORMATION_MESSAGE );
28
29 System.exit( 0 ); Histogram.java
30
31 } // end main
32
33 } // end class Histogram

• Using the elements of an array as counters

– Use a series of counter variables to summarize data

1 // Fig. 7.7: RollDie.java Outline
2 // Roll a six-sided die 6000 times.
4 RollDie.java
Declare frequency as
5 public class RollDie {
6
array of 7 ints
8 { Generate 6000 random Declare frequency
9 int frequency[] = new int[ 7 ]; integers in range 1-6 as array of 7 ints
10
11 // roll die 6000 times; use die value as frequency index
12 for ( int roll = 1; roll <= 6000; roll++ )
Lines 12-13
13 ++frequency[ 1 + ( int ) ( Math.random() * 6 ) ]; Generate 6000
14 random integers in
15 String output = "Face\tFrequency";
Incrementfrequency values at range 1-6
16
17 // append frequencies to
index associated with random number
String output
18 for ( int face = 1; face < frequency.length; face++ ) Line 13
19 output += "\n" + face + "\t" + frequency[ face ]; Increment
20 frequency values at
21 JTextArea outputArea = new JTextArea(); index associated with
23
random number
25 "Rolling a Die 6000 Times", JOptionPane.INFORMATION_MESSAGE );
26
28
29 } // end main
30
31 } // end class RollDie
• Using arrays to analyze survey results

– 40 students rate the quality of food
• 1-10 Rating scale: 1 mean awful, 10 means excellent
– Place 40 responses in array of integers
– Summarize results

1 // Fig. 7.8: StudentPoll.java Outline
2 // Student poll program.
Declare responses as
3 import javax.swing.*; Declare
array to store frequency as array of 11
40 responses
4 StudentPoll.jav
int and ignore the first element
5 public class StudentPoll {
6
a
7 public static void main( String args[] )
8 { Lines 9-11
9 int responses[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1, 6, 3, 8, 6, Declare responses
10 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 5, 6, 7, 5, 6,
as array to store 40
11 4, 8, 6, 8, 10 };
12 int frequency[] = new int[ 11 ];
responses
13
14 // for each answer, select responses element and use that value Line 12
15 // as frequency index to determine element to increment Declare frequency
16 for ( int answer = 0; answer < responses.length; answer++ )
as array of 11 int
17 ++frequency[ responses[ answer ] ];
18
For each response, increment
and ignore the first
19 String output = "Rating\tFrequency\n"; frequency values at index element
20 associated with that response
21 // append frequencies to String output Lines 16-17
22 for ( int rating = 1; rating < frequency.length; rating++ )
23 output += rating + "\t" + frequency[ rating ] + "\n";
For each response,
24 increment
25 JTextArea outputArea = new JTextArea(); frequency values at
26 outputArea.setText( output ); index associated with
27
that response

29 "Student Poll Program", JOptionPane.INFORMATION_MESSAGE );
30
31 System.exit( 0 ); StudentPoll.jav
32
33 } // end main
a
34
35 } // end class StudentPoll

• Some additional points

– When looping through an array
• Index should never go below 0
• Index should be less than total number of array elements
– When invalid array reference occurs
• Java generates ArrayIndexOutOfBoundsException
– Chapter 15 discusses exception handling

7.5 References and Reference Parameters
• Two ways to pass arguments to methods

– Pass-by-value
• Copy of argument’s value is passed to called method
• In Java, every primitive is pass-by-value
– Pass-by-reference
• Caller gives called method direct access to caller’s data
• Called method can manipulate this data
• Improved performance over pass-by-value
• In Java, every object is pass-by-reference
– In Java, arrays are objects
• Therefore, arrays are passed to methods by reference

7.6 Passing Arrays to Methods
• To pass array argument to a method

– Specify array name without brackets
• Array hourlyTemperatures is declared as
int hourlyTemperatures = new int[ 24 ];
• The method call

modifyArray( hourlyTemperatures );
• Passes array hourlyTemperatures to method

modifyArray

1 // Fig. 7.9: PassArray.java Outline
2 // Passing arrays and individual array elements to methods.
3 import java.awt.Container;
4 import javax.swing.*; PassArray.java
5
6 public class PassArray extends JApplet {
7 Line 15
8 // initialize applet Declare 5-int
9 public void init() Declare 5-int array array with initializer
10 { with initializer list list
12 Container container = getContentPane();
13 container.add( outputArea ); Line 24
14 Pass array by
15 int array[] = { 1, 2, 3, 4, 5 }; Pass array by reference to
reference to method
16 method modifyArray modifyArray
17 String output = "Effects of passing entire array by reference:\n" +
18 "The values of the original array are:\n";
19
20 // append original array elements to String output
22 output += " " + array[ counter ];
23
24 modifyArray( array ); // array passed by reference
25
26 output += "\n\nThe values of the modified array are:\n";
27

28 // append modified array elements to String output Outline
31 PassArray.java
32 output += "\n\nEffects of passing array element by value:\n" +
33 "array[3] before modifyElement: " + array[ 3 ];
34 Line 35
35 modifyElement( array[ 3 ] ); // attempt to modify array[ 3 ] Pass array[3] by
36 Pass array[3] by value to value to method
37 output += "\narray[3] after modifyElement: " +modifyElement
method array[ 3 ];
modifyElement
39
40 } // end method init Method modifyArray Lines 43-47
41 manipulates the array directly Method
42 // multiply each element of an array by 2 modifyArray
43 public void modifyArray( int array2[] )
manipulates the array
44 {
45 for ( int counter = 0; counter < array2.length; counter++ ) directly
46 array2[ counter ] *= 2;
47 } Method modifyElement Lines 50-53
48 manipulates a primitive’s copy Method
49 // multiply argument by 2
50 public void modifyElement( int element )
modifyElement
51 { manipulates a
52 element *= 2; primitive’s copy
53 }
54 The original primitive is left unmodified
Lines 52
55 } // end class PassArray
The original primitive
is left unmodified
Outline
PassArray.java
The object passed-by-reference

is modified
The primitive passed-by-value

is unmodified

7.7 Sorting Arrays
• Sorting data
– Attracted intense research in computer-science field
– Bubble sort
• Smaller values “bubble” their way to top of array
• Larger values “sink” to bottom of array
• Use nested loops to make several passes through array
– Each pass compares successive pairs of elements
• Pairs are left along if increasing order (or equal)
• Pairs are swapped if decreasing order

1 // Fig. 7.10: BubbleSort.java Outline
2 // Sort an array's values into ascending order.
3 import java.awt.*;
4 import javax.swing.*; BubbleSort.java
5
6 public class BubbleSort extends JApplet { Line 15
7 Declare 10-int
8 // initialize applet
array with initializer
9 public void init() Declare 10-int array
10 {
list
with initializer list
12 Container container = getContentPane(); Line 23
13 container.add( outputArea ); Pass array by
14 reference to method
15 int array[] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; bubbleSort
Pass array by reference to method to sort
16 array
bubbleSort to sort array
17 String output = "Data items in original order\n";
18
19 // append original array values to String output
22
23 bubbleSort( array ); // sort array
24
25 output += "\n\nData items in ascending order\n";
26

27 // append sorted\ array values to String output Outline
30 BubbleSort.java
32
33 } // end method init Line 36
34 Method
35 // sort elements of array with bubble sort bubbleSort
Method bubbleSort receives
36 public void bubbleSort( int array2[] )
receives array
array reference as parameter
37 {
38 // loop to control number of passes
reference as parameter
39 for ( int pass = 1; pass < array2.length; pass++ ) {
40 Lines 39-53
41 // loop to control number of comparisons Use loop and nested
42 for ( int element = 0;
Use loop and nested loop to make
loop to make passes
43 element < array2.length - 1;
44 element++ ) { passes through array through array
45
46 // compare side-by-side elements and swap them if Lines 48-49
47 // first element is greater than second element If pairs are in
48 if ( array2[ element ] > array2[ element + 1 ] )
49 swap( array2, element, element + 1 );
decreasing order,
50 invoke method swap
51 } // end loop to control comparisons to swap pairs
52
53 } // end loop to control passes If pairs are in decreasing order,
54 invoke method swap to swap pairs
55 } // end method bubbleSort

56 Outline
57 // swap two elements of an array
58 public void swap( int array3[], int first, int second )
59 { BubbleSort.java
60 int hold; // temporary holding area for swap
61 Method swap swaps two Lines 58-65
62 hold = array3[ first ]; values in array reference Method swap swaps
63 array3[ first ] = array3[ second ];
two values in array
64 array3[ second ] = hold;
65 }
reference
66
67 } // end class BubbleSort

7.8 Searching Arrays: Linear Search and
Binary Search
• Searching
– Finding elements in large amounts of data
• Determine whether array contains value matching key value
– Linear searching
– Binary searching

Binary Search (Cont.)
• Linear search
– Compare each array element with search key
• If search key found, return element index
• If search key not found, return –1 (invalid index)
– Works best for small or unsorted arrays
– Inefficient for larger arrays

1 // Fig. 7.11: LinearSearch.java Outline
2 // Linear search of an array.
4 import java.awt.event.*; LinearSearch.ja
6
va
7 public class LinearSearch extends JApplet implements ActionListener {
8 Line 11
9 JLabel enterLabel, resultLabel; Declare array of ints Declare array of
10 JTextField enterField, resultField;
ints
11 int array[];
12
13 // set up applet's GUI
14 public void init()
15 {
16 // get content pane and set its layout to FlowLayout
18 container.setLayout( new FlowLayout() );
19
20 // set up JLabel and JTextField for user input
21 enterLabel = new JLabel( "Enter integer search key" );
22 container.add( enterLabel );
23
24 enterField = new JTextField( 10 );
25 container.add( enterField );
26
27 // register this applet as enterField's action listener
28 enterField.addActionListener( this );
29

30 // set up JLabel and JTextField for displaying results Outline
31 resultLabel = new JLabel( "Result" );
32 container.add( resultLabel );
33 LinearSearch.ja
34 resultField = new JTextField( 20 );
35 resultField.setEditable( false );
va
36 container.add( resultField ); Lines 39-42
37 Allocate 100 ints
38 // create array and populate with even Create
integers 0 to
100 198 for array and for array and
ints
39 array = new int[ 100 ];
populate array with even ints populate array with
40
even ints
42 array[ counter ] = 2 * counter;
43 Line 50
44 } // end method init Loop through array Loop through array
45
46 // search array for specified key value
47 public int linearSearch( int array2[], int key ) Lines 53-54
48 { If array element at
49 // loop through array elements index matches search
50 for ( int counter = 0; counter < array2.length; counter++ ) key, return index
51
52 // if array element equals key value, return location
53 if ( array2[ counter ] == key )
54 return counter; If array element at index matches
55 search key, return index
56 return -1; // key not found
57
58 } // end method linearSearch

59 Invoked when user presses Enter Outline
60 // obtain user input and call method linearSearch
61 public void actionPerformed( ActionEvent actionEvent )
62 { LinearSearch.ja
63 // input also can be obtained with enterField.getText()
64 String searchKey = actionEvent.getActionCommand();
va
65
66 // pass array reference to linearSearch; normally, a reference to an Line 61
67 // array is passed to a method to search corresponding array object Invoked when user
68 int element = linearSearch( array, Integer.parseInt( searchKey ) );
presses Enter
69
70 // display search result Invoke method linearSearch, using
71 if ( element != -1 ) Line 68
array and search key as arguments
72 resultField.setText( "Found value in element " + element ); Invoke method
73 else linearSearch,
74 resultField.setText( "Value not found" );
using array and
75
76 } // method actionPerformed search key as
77 arguments
78 } // end class LinearSearch

Binary Search (Cont.)
• Binary search
– Efficient for large, sorted arrays
– Eliminates half of the elements in search through each pass
• Compare middle array element to search key
– If element equals key
• Return array index
– If element is less than key
• Repeat search on first half of array
– If element is greater then key
• Repeat search on second half of array
– Continue search until
• element equals search key (success)
• Search contains one element not equal to key (failure)

1 // Fig. 7.12: BinarySearch.java Outline
2 // Binary search of an array.
4 import java.awt.event.*; BinarySearch.ja
5 import java.text.*;
6
va
8 Line 14
9 public class BinarySearch extends JApplet implements ActionListener { Declare array of
10 JLabel enterLabel, resultLabel;
ints
11 JTextField enterField, resultField;
12 JTextArea output; Declare array of ints
13
14 int array[];
15 String display = "";
16
17 // set up applet's GUI
19 {
20 // get content pane and set its layout to FlowLayout
22 container.setLayout( new FlowLayout() );
23
24 // set up JLabel and JTextField for user input
25 enterLabel = new JLabel( "Enter integer search key" );
26 container.add( enterLabel );
27
28 enterField = new JTextField( 10 );
29 container.add( enterField );
30

31 // register this applet as enterField's action listener Outline
32 enterField.addActionListener( this );
33
34 // set up JLabel and JTextField for displaying results BinarySearch.ja
35 resultLabel = new JLabel( "Result" );
36 container.add( resultLabel );
va
37
38 resultField = new JTextField( 20 ); Lines 48-51
39 resultField.setEditable( false ); Allocate 15 ints for
40 container.add( resultField );
array and populate
41
42 // set up JTextArea for displaying comparison data
array with even
43 output = new JTextArea( 6, 60 ); ints
44 Allocate 1512
output.setFont( new Font( "Monospaced", Font.PLAIN, ints
) );for array and
45 container.add( output );
populate array with even intsLine 56
46
Invoked when user
47 // create array and fill with even integers 0 to 28
48 array = new int[ 15 ]; presses Enter
49
51 array[ counter ] = 2 * counter;
52
53 } // end method init
54 Invoked when user presses Enter
55 // obtain user input and call method binarySearch
56 public void actionPerformed( ActionEvent actionEvent )
57 {
58 // input also can be obtained with enterField.getText()
59 String searchKey = actionEvent.getActionCommand();
60

61 // initialize display string for new search Outline
62 display = "Portions of array searched\n";
63
64 // perform binary search BinarySearch.ja
65 int element = binarySearch( array, Integer.parseInt( searchKey ) );
66
va
67 output.setText( display );
Invoke method binarySearch, using
Line 65
68 array and search key as arguments
Invoke method
69 // display search result binarySearch,
70 if ( element != -1 )
using array and
71 resultField.setText( "Found value in element " + element );
72 else
search key as
73 resultField.setText( "Value not found" ); arguments
74
75 } // end method actionPerformed
76
77 // method to perform binary search of an array
78 public int binarySearch( int array2[], int key )
79 {
80 int low = 0; // low element index
81 int high = array2.length - 1; // high element index
82 int middle; // middle element index
83
84 // loop until low index is greater than high index
85 while ( low <= high ) {
86 middle = ( low + high ) / 2; // determine middle index
87
88 // display subset of array elements used in this
89 // iteration of binary search loop
90 buildOutput( array2, low, middle, high );

91 Outline
92 // if key matches middle element, return middle location
93 if ( key == array[ middle ] ) If search key matches middle array
94 return middle; element, return element index BinarySearch.ja
95
96 // if key less than middle element, set new high element
va
97 else if ( key < array[ middle ] ) Lines 93-94
98 high = middle - 1; If search key is greater than If search key matches
middle array
99 element,
If searchrepeat
key issearch middlearray
on second
less than array half array
middle
100 // key greater than middle element, set new low element
element, return
element, repeat search on first array half
101 else
102 low = middle + 1;
element index
103 Lines 97-98
104 } // end while If search key is less
105 than middle array
106 return -1; // key not found
element, repeat search
107
108 } // end method binarySearch
Method buildOutput displayson first array half
109 array contents being searched
Lines 101-102
110 // build row of output showing subset of array elements If search key is greater
111 // currently being processed than middle array
112 void buildOutput( int array3[], int low, int middle, int high )
element, repeat search
113 {
114 // create 2-digit integer number format
on second array half
115 DecimalFormat twoDigits = new DecimalFormat( "00" ); Lines 112-137
116 Method build-
Output displays
array contents being
searched
117 // loop through array elements Outline
118 for ( int counter = 0; counter < array3.length; counter++ ) {
119
120 // if counter outside current array subset, append BinarySearch.ja
121 // padding spaces to String display
122 if ( counter < low || counter > high )
va
123 display += " ";
124 Line 128
125 // if middle element, append element to String display Display an asterisk
126 // followed by asterisk (*) to indicate middle element
next to middle
127 else if ( counter == middle )
128 display += twoDigits.format( array3[ counter ] ) + "* ";
element
129
130 else // append element to String display
131 display += twoDigits.format( array3[ counter ] ) + " ";
132
133 } // end for
134
135 display += "\n"; Display an asterisk next to middle element
136
137 } // end method buildOutput
138
139 } // end class BinarySearch

Outline
BinarySearch.ja
va

7.9 Multidimensional Arrays
• Multidimensional arrays
– Tables with rows and columns
• Two-dimensional array
• Declaring two-dimensional array b[2][2]
int b[][] = { { 1, 2 }, { 3, 4 } };
– 1 and 2 initialize b[0][0] and b[0][1]
– 3 and 4 initialize b[1][0] and b[1][1]
int b[][] = { { 1, 2 }, { 3, 4, 5 } };
– row 0 contains elements 1 and 2
– row 1 contains elements 3, 4 and 5

7.9 Multidimensional Arrays (Cont.)
• Creating multidimensional arrays

– Can be allocated dynamically
• 3-by-4 array
int b[][];
b = new int[ 3 ][ 4 ];
• Rows can have different number of columns
int b[][];
b = new int[ 2 ][ ]; // allocate rows
b[ 0 ] = new int[ 5 ]; // allocate row 0
b[ 1 ] = new int[ 3 ]; // allocate row 1

Column 0 Column 1 Column 2 Column 3
Row 0
a[ 0 ][ 0 ] a[ 0 ][ 1 ] a[ 0 ][ 2 ] a[ 0 ][ 3 ]
Row 1
a[ 1 ][ 0 ] a[ 1 ][ 1 ] a[ 1 ][ 2 ] a[ 1 ][ 3 ]
Row 2
a[ 2 ][ 0 ] a[ 2 ][ 1 ] a[ 2 ][ 2 ] a[ 2 ][ 3 ]
Column index
Row index
Array name
Fig. 7.13 Two-dimensional array with three rows and four columns.

2 // Initializing two-dimensional arrays.
3 import java.awt.Container;
4 import javax.swing.*; InitArray.java
5
6 public class InitArray extends JApplet {
Declare array1 with six Line 16
7 JTextArea outputArea;
8
initializers in two sublists Declare array1 with
six initializers in two
9 // set up GUI and initialize applet
sublists
11 {
Declare array2 with six
12 outputArea = new JTextArea(); initializers in three sublists Line 17
13 Container container = getContentPane(); Declare array2 with
14 container.add( outputArea ); six initializers in three
15 sublists
16 int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } };
17 int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } };
18
19 outputArea.setText( "Values in array1 by row are\n" );
20 buildOutput( array1 );
21
22 outputArea.append( "\nValues in array2 by row are\n" );
23 buildOutput( array2 );
24
26

27 // append rows and columns of an array to outputArea Outline
28 public void buildOutput( int array[][] )
29 { array[row].length returns number
30 // loop through array's rows
of columns associated with row InitArray.java
subscript
31 for ( int row = 0; row < array.length; row++ ) {
32
33 // loop through columns of current row Line 34
34 for ( int column = 0; column < array[ row ].length; column++ ) array[row].leng
35 outputArea.append( array[ row ][ column ] + " " ); th returns number of
36
columns associated
37 outputArea.append( "\n" );
38 }
with row subscript
39
Use double-bracket notation to access
40 } // end method buildOutput Line 35
41 two-dimensional array values
Use double-bracket
notation to access two-
dimensional array
values

1 // Fig. 7.15: DoubleArray.java Outline
2 // Two-dimensional array example.
Declare grades as 3-by-4 array
4 import javax.swing.*; DoubleArray.jav
5 a
6 public class DoubleArray extends JApplet {
7 int grades[][] = { { 77, 68, 86, 73 },
Lines 7-9
8 { 96, 87, 89, 81 },
Declare grades as 3-
9 { 70, 90, 86, 81 } };
10
by-4 array
11 int students, exams; Each row represents a student; each
12 String output; Lines 7-9
column represents an exam grade
13 JTextArea outputArea; Each row represents a
14 student; each column
15 // initialize fields represents an exam
16 public void init() grade
17 {
18 students = grades.length; // number of students
19 exams = grades[ 0 ].length; // number of exams
20
21 // create JTextArea and attach to applet
22 outputArea = new JTextArea();
24 container.add( outputArea );
25

26 // build output string Outline
27 output = "The array is:\n";
28 buildString();
29 DoubleArray.jav
30 // call methods minimum and maximum
31 output += "\n\nLowest grade: " + minimum() +
a minimum and
Determine
32 "\nHighest grade: " + maximum() + "\n"; maximum for all student
33 Lines 31-32
34 // call method average to calculate each student's average Determine minimum
35 for ( int counter = 0; counter < students; counter++ )
and maximum for all
36 output += "\nAverage for student " + counter + " is " +
37 average( grades[ counter ] ); // pass one row of array grades
student
38
39 // change outputArea's display font Lines 35-37
40 outputArea.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) ); Determine average for
41
each student
42 // place output string in outputArea
Determine average
44
for each student
46
47 // find minimum grade
48 public int minimum()
49 {
50 // assume first element of grades array is smallest
51 int lowGrade = grades[ 0 ][ 0 ];
52

53 // loop through rows of grades array Outline
54 for ( int row = 0; row < students; row++ ) Use a nested loop to search
55 for lowest grade in series
56 // loop through columns of current row DoubleArray.jav
57 for ( int column = 0; column < exams; column++ )
58
a
59 // if grade is less than lowGrade, assign it to lowGrade
60 if ( grades[ row ][ column ] < lowGrade ) Lines 54-61
61 lowGrade = grades[ row ][ column ]; Use a nested loop to
62
search for lowest
63 return lowGrade; // return lowest grade
64
grade in series
65 } // end method minimum
Use a nested loop to search
66 Lines 74-81
67 // find maximum grade for highest grade in series
Use a nested loop to
68 public int maximum()
search for highest
69 {
70 // assume first element of grades array is largest grade in series
71 int highGrade = grades[ 0 ][ 0 ];
72
73 // loop through rows of grades array
74 for ( int row = 0; row < students; row++ )
75
76 // loop through columns of current row
78
79 // if grade is greater than highGrade, assign it to highGrade
80 if ( grades[ row ][ column ] > highGrade )
81 highGrade = grades[ row ][ column ];

82 Outline
83 return highGrade; // return highest grade
84
85 } // end method maximum DoubleArray.jav
86 Method average takes array of
87 // determine average grade for particular student (or student
set of grades)
a
test results as parameter
88 public double average( int setOfGrades[] )
89 { Line 88
90 int total = 0; // initialize total Calculate sum of array elementsMethod average
91
takes array of student
92 // sum grades for one student
93 for ( int count = 0; count < setOfGrades.length; count++ )
test results as
94 total += setOfGrades[ count ]; parameter
95 Divide by number of
96 // return average of grades elements to get average
Lines 93-94
97 return ( double ) total / setOfGrades.length;
Calculate sum of array
98
99 } // end method average elements
100
101 // build output string Line 97
102 public void buildString() Divide by number of
103 {
104 output += " "; // used to align column heads
elements to get
105 average
106 // create column heads
107 for ( int counter = 0; counter < exams; counter++ )
108 output += "[" + counter + "] ";

109 Outline
110 // create rows/columns of text representing array grades
111 for ( int row = 0; row < students; row++ ) {
112 output += "\ngrades[" + row + "] "; DoubleArray.jav
113
a
115 output += grades[ row ][ column ] + " ";
116 }
117
118 } // end method buildString
119
120 } // end class DoubleArray


Chapter 7 - Arrays: 2003 Prentice Hall, Inc. All Rights Reserved

Uploaded by

Copyright:

Available Formats

Chapter 7 - Arrays: 2003 Prentice Hall, Inc. All Rights Reserved

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 7 - Arrays: 2003 Prentice Hall, Inc. All Rights Reserved

Uploaded by

Copyright:

Available Formats

Chapter 7 - Arrays

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

Index (or subscript) of c[ 10 ] 6453

Fig. 7.1 A 12-element array.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

• Declaring and Creating arrays

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

• Creating and initializing an array

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

Each int is initialized Each int is

 2003 Prentice Hall, Inc.

• Using an array initializer

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

Each array element

 2003 Prentice Hall, Inc.

• Calculating the value to store in each array

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

• Summing the elements of an array

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

• Using histograms do display array data graphically

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

• Using the elements of an array as counters

 2003 Prentice Hall, Inc. All rights reserved.

• Using arrays to analyze survey results

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

• Some additional points

 2003 Prentice Hall, Inc. All rights reserved.

• Two ways to pass arguments to methods

 2003 Prentice Hall, Inc. All rights reserved.

• To pass array argument to a method

• The method call

• Passes array hourlyTemperatures to method

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

The object passed-by-reference

The primitive passed-by-value

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc. All rights reserved.

 2003 Prentice Hall, Inc.

 2003 Prentice Hall, Inc.