Declaring and Creating arrays
1 // Fig. 7.2: InitArray.java
2 // Creating an array.
3 import javax.swing.*;
4
5 public class InitArray {
6
7 public static void main( String args[] )
8 {
9 int array[]; // declare reference to an array
10
11 array = new int[ 10 ]; // create array
12
13 String output = "Index\tValue\n";
14
15 // append each array element's value to String output
16 for ( int counter = 0; counter < array.length; counter++ )
17 output += counter + "\t" + array[ counter ] + "\n";
18
19 JTextArea outputArea = new JTextArea();
20 outputArea.setText( output );
21
22 JOptionPane.showMessageDialog( null, outputArea,
23 "Initializing an Array of int Values",
24 JOptionPane.INFORMATION_MESSAGE );
25
26 System.exit( 0 );
27
28 } // end main
29
30 } // end class InitArray
1 // Fig. 7.3: InitArray.java
2 // Initializing an array with a declaration.
3 import javax.swing.*;
4
5 public class InitArray {
6
7 public static void main( String args[] )
8 {
9 // array initializer specifies number of elements and
10 // value for each element
11 int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
12
13 String output = "Index\tValue\n";
14
15 // append each array element's value to String output
16 for ( int counter = 0; counter < array.length; counter++ )
17 output += counter + "\t" + array[ counter ] + "\n";
18
19 JTextArea outputArea = new JTextArea();
20 outputArea.setText( output );
21
22 JOptionPane.showMessageDialog( null, outputArea,
23 "Initializing an Array with a Declaration",
24 JOptionPane.INFORMATION_MESSAGE );
25
26 System.exit( 0 );
27
28 } // end main
29
30 } // end class InitArray
1 // Fig. 7.4: InitArray.java
2 // Initialize array with the even integers from 2 to 20.
3 import javax.swing.*;
4
5 public class InitArray {
6
7 public static void main( String args[] )
8 {
9 final int ARRAY_LENGTH = 10; // constant
10 int array[]; // reference to int array
11
12 array = new int[ ARRAY_LENGTH ]; // create array
13
14 // calculate value for each array element
15 for ( int counter = 0; counter < array.length; counter++ )
16 array[ counter ] = 2 + 2 * counter;
17
18 String output = "Index\tValue\n";
19
20 for ( int counter = 0; counter < array.length; counter++ )
21 output += counter + "\t" + array[ counter ] + "\n";
22
23 JTextArea outputArea = new JTextArea();
24 outputArea.setText( output );
25
26 JOptionPane.showMessageDialog( null, outputArea,
27 "Initializing to Even Numbers from 2 to 20",
28 JOptionPane.INFORMATION_MESSAGE );
29
30 System.exit( 0 );
31
32 } // end main
33
34 } // end class InitArray
1 // Fig. 7.5: SumArray.java
2 // Total the values of the elements of an array.
3 import javax.swing.*;
4
5 public class SumArray {
6
7 public static void main( String args[] )
8 {
9 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
10 int total = 0;
11
12 // add each element's value to total
13 for ( int counter = 0; counter < array.length; counter++ )
14 total += array[ counter ];
15
16 JOptionPane.showMessageDialog( null,
17 "Total of array elements: " + total,
18 "Sum the Elements of an Array",
19 JOptionPane.INFORMATION_MESSAGE );
20
21 System.exit( 0 );
22
23 } // end main
24
25 } // end class SumArray
1 // Fig. 7.6: Histogram.java
2 // Histogram printing program.
3 import javax.swing.*;
4
5 public class Histogram {
6
7 public static void main( String args[] )
8 {
9 int array[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
10
11 String output = "Element\tValue\tHistogram";
12
13 // for each array element, output a bar in histogram
14 for ( int counter = 0; counter < array.length; counter++ ) {
15 output += "\n" + counter + "\t" + array[ counter ] + "\t";
16
17 // print bar of asterisks
18 for ( int stars = 0; stars < array[ counter ]; stars++ )
19 output += "*";
20
21 } // end outer for
22
23 JTextArea outputArea = new JTextArea();
24 outputArea.setText( output );
25
26 JOptionPane.showMessageDialog( null, outputArea,
27 "Histogram Printing Program", JOptionPane.INFORMATION_MESSAGE );
28
29 System.exit( 0 );
30
31 } // end main
32
33 } // end class Histogram
1 // Fig. 7.7: RollDie.java
2 // Roll a six-sided die 6000 times.
3 import javax.swing.*;
4
5 public class RollDie {
6
7 public static void main( String args[] )
8 {
9 int frequency[] = new int[ 7 ];
10
11 // roll die 6000 times; use die value as frequency index
12 for ( int roll = 1; roll <= 6000; roll++ )
13 ++frequency[ 1 + ( int ) ( Math.random() * 6 ) ];
14
15 String output = "Face\tFrequency";
16
17 // append frequencies to String output
18 for ( int face = 1; face < frequency.length; face++ )
19 output += "\n" + face + "\t" + frequency[ face ];
20
21 JTextArea outputArea = new JTextArea();
22 outputArea.setText( output );
23
24 JOptionPane.showMessageDialog( null, outputArea,
25 "Rolling a Die 6000 Times", JOptionPane.INFORMATION_MESSAGE );
26
27 System.exit( 0 );
28
29 } // end main
30
31 } // end class RollDie
1 // Fig. 7.8: StudentPoll.java
2 // Student poll program.
3 import javax.swing.*;
4
5 public class StudentPoll {
6
7 public static void main( String args[] )
8 {
9 int responses[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1, 6, 3, 8, 6,
10 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 5, 6, 7, 5, 6,
11 4, 8, 6, 8, 10 };
12 int frequency[] = new int[ 11 ];
13
14 // for each answer, select responses element and use that value
15 // as frequency index to determine element to increment
16 for ( int answer = 0; answer < responses.length; answer++ )
17 ++frequency[ responses[ answer ] ];
18
19 String output = "Rating\tFrequency\n";
20
21 // append frequencies to String output
22 for ( int rating = 1; rating < frequency.length; rating++ )
23 output += rating + "\t" + frequency[ rating ] + "\n";
24
25 JTextArea outputArea = new JTextArea();
26 outputArea.setText( output );
27
28 JOptionPane.showMessageDialog( null, outputArea,
29 "Student Poll Program", JOptionPane.INFORMATION_MESSAGE );
30
31 System.exit( 0 );
32
33 } // end main
34
35 } // end class StudentPoll
1 // Fig. 7.9: PassArray.java
2 // Passing arrays and individual array elements to methods.
3 import java.awt.Container;
4 import javax.swing.*;
5
6 public class PassArray extends JApplet {
7
8 // initialize applet
9 public void init()
10 {
11 JTextArea outputArea = new JTextArea();
12 Container container = getContentPane();
13 container.add( outputArea );
14
15 int array[] = { 1, 2, 3, 4, 5 };
16
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
21 for ( int counter = 0; counter < array.length; counter++ )
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
29 for ( int counter = 0; counter < array.length; counter++ )
30 output += " " + array[ counter ];
31
32 output += "\n\nEffects of passing array element by value:\n" +
33 "array[3] before modifyElement: " + array[ 3 ];
34
35 modifyElement( array[ 3 ] ); // attempt to modify array[ 3 ]
36
37 output += "\narray[3] after modifyElement: " + array[ 3 ];
38 outputArea.setText( output );
39
40 } // end method init
41
42 // multiply each element of an array by 2
43 public void modifyArray( int array2[] )
44 {
45 for ( int counter = 0; counter < array2.length; counter++ )
46 array2[ counter ] *= 2;
47 }
48
49 // multiply argument by 2
50 public void modifyElement( int element )
51 {
52 element *= 2;
53 }
54
55 } // end class PassArray
1 // Fig. 7.10: BubbleSort.java
2 // Sort an array's values into ascending order.
3 import java.awt.*;
4 import javax.swing.*;
5
6 public class BubbleSort extends JApplet {
7
8 // initialize applet
9 public void init()
10 {
11 JTextArea outputArea = new JTextArea();
12 Container container = getContentPane();
13 container.add( outputArea );
14
15 int array[] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
16
17 String output = "Data items in original order\n";
18
19 // append original array values to String output
20 for ( int counter = 0; counter < array.length; counter++ )
21 output += " " + array[ counter ];
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
28 for ( int counter = 0; counter < array.length; counter++ )
29 output += " " + array[ counter ];
30
31 outputArea.setText( output );
32
33 } // end method init
34
35 // sort elements of array with bubble sort
36 public void bubbleSort( int array2[] )
37 {
38 // loop to control number of passes
39 for ( int pass = 1; pass < array2.length; pass++ ) {
40
41 // loop to control number of comparisons
42 for ( int element = 0;
43 element < array2.length - 1;
44 element++ ) {
45
46 // compare side-by-side elements and swap them if
47 // first element is greater than second element
48 if ( array2[ element ] > array2[ element + 1 ] )
49 swap( array2, element, element + 1 );
50
51 } // end loop to control comparisons
52
53 } // end loop to control passes
54
55 } // end method bubbleSort
56
57 // swap two elements of an array
58 public void swap( int array3[], int first, int second )
59 {
60 int hold; // temporary holding area for swap
61
62 hold = array3[ first ];
63 array3[ first ] = array3[ second ];
64 array3[ second ] = hold;
65 }
66
67 } // end class BubbleSort
1 // Fig. 7.11: LinearSearch.java
2 // Linear search of an array.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6
7 public class LinearSearch extends JApplet implements ActionListener {
8
9 JLabel enterLabel, resultLabel;
10 JTextField enterField, resultField;
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
17 Container container = getContentPane();
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
31 resultLabel = new JLabel( "Result" );
32 container.add( resultLabel );
33
34 resultField = new JTextField( 20 );
35 resultField.setEditable( false );
36 container.add( resultField );
37
38 // create array and populate with even integers 0 to 198
39 array = new int[ 100 ];
40
41 for ( int counter = 0; counter < array.length; counter++ )
42 array[ counter ] = 2 * counter;
43
44 } // end method init
45
46 // search array for specified key value
47 public int linearSearch( int array2[], int key )
48 {
49 // loop through array elements
50 for ( int counter = 0; counter < array2.length; counter++ )
51
52 // if array element equals key value, return location
53 if ( array2[ counter ] == key )
54 return counter;
55
56 return -1; // key not found
57
58 } // end method linearSearch
59
60 // obtain user input and call method linearSearch
61 public void actionPerformed( ActionEvent actionEvent )
62 {
63 // input also can be obtained with enterField.getText()
64 String searchKey = actionEvent.getActionCommand();
65
66 // pass array reference to linearSearch; normally, a reference to an
67 // array is passed to a method to search corresponding array object
68 int element = linearSearch( array, Integer.parseInt( searchKey ) );
69
70 // display search result
71 if ( element != -1 )
72 resultField.setText( "Found value in element " + element );
73 else
74 resultField.setText( "Value not found" );
75
76 } // method actionPerformed
77
78 } // end class LinearSearch
1 // Fig. 7.12: BinarySearch.java
2 // Binary search of an array.
3 import java.awt.*;
4 import java.awt.event.*;
5 import java.text.*;
6
7 import javax.swing.*;
8
9 public class BinarySearch extends JApplet implements ActionListener {
10 JLabel enterLabel, resultLabel;
11 JTextField enterField, resultField;
12 JTextArea output;
13
14 int array[];
15 String display = "";
16
17 // set up applet's GUI
18 public void init()
19 {
20 // get content pane and set its layout to FlowLayout
21 Container container = getContentPane();
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
32 enterField.addActionListener( this );
33
34 // set up JLabel and JTextField for displaying results
35 resultLabel = new JLabel( "Result" );
36 container.add( resultLabel );
37
38 resultField = new JTextField( 20 );
39 resultField.setEditable( false );
40 container.add( resultField );
41
42 // set up JTextArea for displaying comparison data
43 output = new JTextArea( 6, 60 );
44 output.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) );
45 container.add( output );
46
47 // create array and fill with even integers 0 to 28
48 array = new int[ 15 ];
49
50 for ( int counter = 0; counter < array.length; counter++ )
51 array[ counter ] = 2 * counter;
52
53 } // end method init
54
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
62 display = "Portions of array searched\n";
63
64 // perform binary search
65 int element = binarySearch( array, Integer.parseInt( searchKey ) );
66
67 output.setText( display );
68
69 // display search result
70 if ( element != -1 )
71 resultField.setText( "Found value in element " + element );
72 else
73 resultField.setText( "Value not found" );
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
92 // if key matches middle element, return middle location
93 if ( key == array[ middle ] )
94 return middle;
95
96 // if key less than middle element, set new high element
97 else if ( key < array[ middle ] )
98 high = middle - 1;
99
100 // key greater than middle element, set new low element
101 else
102 low = middle + 1;
103
104 } // end while
105
106 return -1; // key not found
107
108 } // end method binarySearch
109
110 // build row of output showing subset of array elements
111 // currently being processed
112 void buildOutput( int array3[], int low, int middle, int high )
113 {
114 // create 2-digit integer number format
115 DecimalFormat twoDigits = new DecimalFormat( "00" );
116
117 // loop through array elements
118 for ( int counter = 0; counter < array3.length; counter++ ) {
119
120 // if counter outside current array subset, append
121 // padding spaces to String display
122 if ( counter <> high )
123 display += " ";
124
125 // if middle element, append element to String display
126 // followed by asterisk (*) to indicate middle element
127 else if ( counter == middle )
128 display += twoDigits.format( array3[ counter ] ) + "* ";
129
130 else // append element to String display
131 display += twoDigits.format( array3[ counter ] ) + " ";
132
133 } // end for
134
135 display += "\n";
136
137 } // end method buildOutput
138
139 } // end class BinarySearch
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
1 // Fig. 7.14: InitArray.java
2 // Initializing two-dimensional arrays.
3 import java.awt.Container;
4 import javax.swing.*;
5
6 public class InitArray extends JApplet {
7 JTextArea outputArea;
8
9 // set up GUI and initialize applet
10 public void init()
11 {
12 outputArea = new JTextArea();
13 Container container = getContentPane();
14 container.add( outputArea );
15
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
25 } // end method init
26
27 // append rows and columns of an array to outputArea
28 public void buildOutput( int array[][] )
29 {
30 // loop through array's rows
31 for ( int row = 0; row < array.length; row++ ) {
32
33 // loop through columns of current row
34 for ( int column = 0; column < array[ row ].length; column++ )
35 outputArea.append( array[ row ][ column ] + " " );
36
37 outputArea.append( "\n" );
38 }
39
40 } // end method buildOutput
41
42 } // end class InitArray
1 // Fig. 7.15: DoubleArray.java
2 // Two-dimensional array example.
3 import java.awt.*;
4 import javax.swing.*;
5
6 public class DoubleArray extends JApplet {
7 int grades[][] = { { 77, 68, 86, 73 },
8 { 96, 87, 89, 81 },
9 { 70, 90, 86, 81 } };
10
11 int students, exams;
12 String output;
13 JTextArea outputArea;
14
15 // initialize fields
16 public void init()
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();
23 Container container = getContentPane();
24 container.add( outputArea );
25
26 // build output string
27 output = "The array is:\n";
28 buildString();
29
30 // call methods minimum and maximum
31 output += "\n\nLowest grade: " + minimum() +
32 "\nHighest grade: " + maximum() + "\n";
33
34 // call method average to calculate each student's average
35 for ( int counter = 0; counter < students; counter++ )
36 output += "\nAverage for student " + counter + " is " +
37 average( grades[ counter ] ); // pass one row of array grades
38
39 // change outputArea's display font
40 outputArea.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) );
41
42 // place output string in outputArea
43 outputArea.setText( output );
44
45 } // end method init
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
54 for ( int row = 0; row < students; row++ )
55
56 // loop through columns of current row
57 for ( int column = 0; column < exams; column++ )
58
59 // if grade is less than lowGrade, assign it to lowGrade
60 if ( grades[ row ][ column ] < lowGrade )
61 lowGrade = grades[ row ][ column ];
62
63 return lowGrade; // return lowest grade
64
65 } // end method minimum
66
67 // find maximum grade
68 public int maximum()
69 {
70 // assume first element of grades array is largest
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
77 for ( int column = 0; column < exams; column++ )
78
79 // if grade is greater than highGrade, assign it to highGrade
80 if ( grades[ row ][ column ] > highGrade )
81 highGrade = grades[ row ][ column ];
82
83 return highGrade; // return highest grade
84
85 } // end method maximum
86
87 // determine average grade for particular student (or set of grades)
88 public double average( int setOfGrades[] )
89 {
90 int total = 0; // initialize total
91
92 // sum grades for one student
93 for ( int count = 0; count < setOfGrades.length; count++ )
94 total += setOfGrades[ count ];
95
96 // return average of grades
97 return ( double ) total / setOfGrades.length;
98
99 } // end method average
100
101 // build output string
102 public void buildString()
103 {
104 output += " "; // used to align column heads
105
106 // create column heads
107 for ( int counter = 0; counter < exams; counter++ )
108 output += "[" + counter + "] ";
109
110 // create rows/columns of text representing array grades
111 for ( int row = 0; row < students; row++ ) {
112 output += "\ngrades[" + row + "] ";
113
114 for ( int column = 0; column < exams; column++ )
115 output += grades[ row ][ column ] + " ";
116 }
117
118 } // end method buildString
119
120 } // end class DoubleArray
0 Comments