Multi-dimensional Arrays in Java: 2D, 3D and Jagged Arrays Explained

public class CinemaSeating {
    public static void main(String[] args) {

        // A cinema with 3 rows and 5 seats per row.
        // Think: seatingChart[rowIndex][seatIndex]
        boolean[][] seatingChart = new boolean[3][5];

        // Reserve row 1, seat 3 (zero-based indices)
        seatingChart[1][3] = true;

        // Reserve row 0, seat 0
        seatingChart[0][0] = true;

        // Print the seating chart — 'X' = reserved, 'O' = available
        System.out.println("=== Cinema Seating Chart ===");
        for (int row = 0; row < seatingChart.length; row++) {
            // seatingChart.length gives the number of ROWS
            System.out.print("Row " + row + ": ");
            for (int seat = 0; seat < seatingChart[row].length; seat++) {
                // seatingChart[row].length gives the number of SEATS in that row
                System.out.print(seatingChart[row][seat] ? " X " : " O ");
            }
            System.out.println(); // Move to next line after each row
        }

        // Demonstrate swapping two rows — only reference swap, no data copy
        System.out.println("\n--- Swapping Row 0 and Row 1 ---");
        boolean[] tempRow = seatingChart[0]; // Save reference to row 0
        seatingChart[0] = seatingChart[1];   // Point row 0 to old row 1
        seatingChart[1] = tempRow;           // Point row 1 to saved row 0

        for (int row = 0; row < seatingChart.length; row++) {
            System.out.print("Row " + row + ": ");
            for (int seat = 0; seat < seatingChart[row].length; seat++) {
                System.out.print(seatingChart[row][seat] ? " X " : " O ");
            }
            System.out.println();
        }
    }
}

import java.util.Arrays;

public class MultiplicationTable {
    public static void main(String[] args) {

        // --- Approach 1: Inline literal for a small, fixed dataset ---
        // A 3x3 magic square where every row, column and diagonal sums to 15
        int[][] magicSquare = {
            {2, 7, 6},
            {9, 5, 1},
            {4, 3, 8}
        };

        // Arrays.deepToString saves writing a nested loop during debugging
        System.out.println("Magic Square: " + Arrays.deepToString(magicSquare));

        // --- Approach 2: Dynamic population ---
        // Build a 5x5 multiplication table at runtime
        int tableSize = 5;
        int[][] multiplicationTable = new int[tableSize][tableSize];

        for (int row = 0; row < tableSize; row++) {
            for (int col = 0; col < tableSize; col++) {
                // (row+1) and (col+1) because we want 1-based multiplication
                multiplicationTable[row][col] = (row + 1) * (col + 1);
            }
        }

        // Pretty-print the multiplication table with aligned columns
        System.out.println("\n=== 5x5 Multiplication Table ===");
        for (int row = 0; row < tableSize; row++) {
            for (int col = 0; col < tableSize; col++) {
                // %4d pads each number to 4 chars wide so columns line up
                System.out.printf("%4d", multiplicationTable[row][col]);
            }
            System.out.println();
        }

        // Verify with deepToString — great for unit tests too
        System.out.println("\nRaw structure: " + Arrays.deepToString(multiplicationTable));
    }
}

public class PascalsTriangle {
    public static void main(String[] args) {

        int numberOfRows = 6;

        // Allocate the outer array — we know how many rows we need
        // but NOT the column count yet (each row has a different length)
        int[][] triangle = new int[numberOfRows][];

        for (int row = 0; row < numberOfRows; row++) {
            // Row 0 has 1 element, row 1 has 2, row N has N+1
            triangle[row] = new int[row + 1]; // Allocate each row individually

            // First and last element of every row is always 1
            triangle[row][0] = 1;
            triangle[row][row] = 1;

            // Fill in the middle values: each cell = sum of two cells above it
            for (int col = 1; col < row; col++) {
                triangle[row][col] = triangle[row - 1][col - 1] + triangle[row - 1][col];
            }
        }

        // Print Pascal's triangle — each row has a different length
        System.out.println("=== Pascal's Triangle (6 rows) ===");
        for (int row = 0; row < triangle.length; row++) {
            // Indent to create the triangular shape
            for (int space = 0; space < numberOfRows - row - 1; space++) {
                System.out.print("  ");
            }
            // Use triangle[row].length — NOT numberOfRows — because rows differ
            for (int col = 0; col < triangle[row].length; col++) {
                System.out.printf("%4d", triangle[row][col]);
            }
            System.out.println();
        }

        // Show the jagged nature explicitly
        System.out.println("\nRow lengths:");
        for (int row = 0; row < triangle.length; row++) {
            System.out.println("  triangle[" + row + "].length = " + triangle[row].length);
        }
    }
}

public class BuildingRoomTracker {

    // Represents the occupancy status of every room in a 3-floor building
    // Each floor has 4 rows and 3 columns of rooms
    public static void main(String[] args) {

        final int FLOORS = 3;
        final int ROWS_PER_FLOOR = 4;
        final int ROOMS_PER_ROW = 3;

        // Declare a 3D array: [floor][row][roomNumber]
        boolean[][][] buildingOccupancy = new boolean[FLOORS][ROWS_PER_FLOOR][ROOMS_PER_ROW];

        // Check in some guests — syntax reads naturally as [floor][row][room]
        buildingOccupancy[0][1][2] = true; // Floor 0, Row 1, Room 2
        buildingOccupancy[1][0][0] = true; // Floor 1, Row 0, Room 0
        buildingOccupancy[2][3][1] = true; // Floor 2, Row 3, Room 1
        buildingOccupancy[1][2][2] = true; // Floor 1, Row 2, Room 2

        // Count total occupied rooms across the whole building
        int occupiedCount = 0;

        for (int floor = 0; floor < buildingOccupancy.length; floor++) {
            System.out.println("--- Floor " + floor + " ---");
            for (int row = 0; row < buildingOccupancy[floor].length; row++) {
                System.out.print("  Row " + row + ": ");
                for (int room = 0; room < buildingOccupancy[floor][row].length; room++) {
                    boolean isOccupied = buildingOccupancy[floor][row][room];
                    System.out.print(isOccupied ? "[X]" : "[ ]");
                    if (isOccupied) occupiedCount++;
                }
                System.out.println();
            }
        }

        int totalRooms = FLOORS * ROWS_PER_FLOOR * ROOMS_PER_ROW;
        System.out.println("\nOccupied: " + occupiedCount + " / " + totalRooms + " rooms");
        System.out.printf("Occupancy rate: %.1f%%%n", (occupiedCount * 100.0) / totalRooms);
    }
}