Expt 1 - Part 1, Part 2 & Part 3

Explanation

This Java program demonstrates how to declare, initialize, and print a "static" 2D array. A static 2D array, in this context, refers to an array whose size and initial values are fixed at compile time (declared directly in the code).

1. Class Declaration: The code starts by defining a class named array_2d. In Java, all executable code must reside within a class.
2. Main Method: public static void main(String[] args) is the entry point of any Java application. When you run this program, execution begins here.
3. 2D Array Declaration and Initialization:
   • int[][] num = {{2,5}, {12,10}}; declares a two-dimensional array named num.
   • int[][] indicates that num is an array of arrays, where each inner array holds int (integer) values.
   • {{2,5}, {12,10}} directly initializes the array. It creates two "rows". The first row contains 2 and 5, and the second row contains 12 and 10. This effectively creates a 2x2 matrix.
4. Printing the Array (Outer Structure):
   • System.out.print("Static 2D Array: ["); prints a descriptive label "Static 2D Array: " followed by an opening square bracket [ to start the visual representation of the entire 2D array. print is used so that the subsequent output appears on the same line.
5. Iterating Through Rows (Outer Loop):
   • for(int i=0; i<num.length; i++){ ... } is the outer for loop.
   • int i=0: Initializes a loop counter i to 0. This i will represent the current row index.
   • i<num.length: The loop continues as long as i is less than the number of rows in the num array. num.length gives the total number of inner arrays (rows), which is 2 in this case.
   • i++: Increments i after each iteration, moving to the next row.
   • Inside this loop, System.out.print("["); prints an opening square bracket for each row, making the output look like [[...][...].
6. Iterating Through Columns (Inner Loop):
   • for(int j=0; j<num[i].length; j++){ ... } is the inner for loop, nested inside the outer loop.
   • int j=0: Initializes a loop counter j to 0. This j will represent the current column index within the current row.
   • j<num[i].length: The loop continues as long as j is less than the number of elements (columns) in the current row (num[i]). num[i].length gives the number of elements in the i-th row, which is 2 for both rows in this example.
   • j++: Increments j after each iteration, moving to the next column in the current row.
   • Inside this loop, System.out.print(num[i][j] + ","); accesses and prints the element at the current row i and column j (num[i][j]). A comma , is appended after each element.
7. Closing Row Bracket:
   • After the inner loop finishes (meaning all elements of the current row i have been printed), System.out.print("]"); prints a closing square bracket for that row.
8. Final Closing Bracket and Newline:
   • After the outer loop finishes (meaning all rows have been processed and printed), System.out.println("]"); prints the final closing square bracket for the entire 2D array representation and then moves the cursor to the next line.

In essence, the program iterates through each row, and for each row, it iterates through each element, printing them with commas and brackets to visually represent the 2D array structure.

Algorithm

The algorithm used to print the static 2D array is as follows:

1. Start: Begin execution in the main method.
2. Declare and Initialize 2D Array: Create an integer 2D array num and initialize it with predefined values {{2,5}, {12,10}}.
3. Print Initial Label: Display "Static 2D Array: [" to the console.
4. Iterate Through Rows: a. Start a loop that iterates from i = 0 up to (but not including) the number of rows (num.length). b. For each row i, print an opening square bracket [.
5. Iterate Through Columns (Nested Loop): a. Inside the row loop, start another loop that iterates from j = 0 up to (but not including) the number of columns in the current row (num[i].length). b. For each element at num[i][j], print its value followed by a comma ,.
6. Close Row Bracket: After the inner loop completes for a row, print a closing square bracket ].
7. Close Array Bracket: After the outer loop completes (all rows are processed), print a final closing square bracket ] followed by a newline character.
8. End: Terminate the program.