Jagged Arrays in Java — NPE from Null Rows

package io.thecodeforge.jaggedarrays;

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

        // A standard rectangular 2D array — looks uniform, but each row
        // is a separate int[] object allocated on the heap.
        int[][] rectangle = new int[3][4];

        // We can prove rows are independent objects by checking each row's length.
        System.out.println("Rectangular array — all rows report the same length:");
        for (int rowIndex = 0; rowIndex < rectangle.length; rowIndex++) {
            System.out.println("  rectangle[" + rowIndex + "].length = " + rectangle[rowIndex].length);
        }

        // Now replace row 1 entirely with a shorter array.
        // This is legal because rectangle[1] is just a reference.
        rectangle[1] = new int[2]; // row 1 now has only 2 columns

        System.out.println("\nAfter replacing row 1 with a 2-element array:");
        for (int rowIndex = 0; rowIndex < rectangle.length; rowIndex++) {
            System.out.println("  rectangle[" + rowIndex + "].length = " + rectangle[rowIndex].length);
        }

        // This confirms: 2D arrays in Java are arrays of array references,
        // not a single flat memory block.
    }
}

package io.thecodeforge.jaggedarrays;

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

        // ── Pattern 1: Allocate-then-fill ─────────────────────────────────
        // Useful when row sizes come from data you read at runtime.

        // Imagine storing the number of goals scored by each player
        // across a variable number of matches they participated in.
        int numberOfPlayers = 4;
        int[][] playerGoals = new int[numberOfPlayers][]; // outer array only — rows are null!

        // Each player played a different number of matches.
        int[] matchesPlayed = {3, 5, 2, 4};

        for (int player = 0; player < numberOfPlayers; player++) {
            // Allocate each row to exactly the size this player needs.
            playerGoals[player] = new int[matchesPlayed[player]];
        }

        // Populate with sample goal data.
        playerGoals[0] = new int[]{1, 0, 2};          // Player 0: 3 matches
        playerGoals[1] = new int[]{0, 1, 1, 0, 3};   // Player 1: 5 matches
        playerGoals[2] = new int[]{2, 1};             // Player 2: 2 matches
        playerGoals[3] = new int[]{0, 0, 1, 2};      // Player 3: 4 matches

        System.out.println("── Player Goal Records (Allocate-then-fill) ──");
        for (int player = 0; player < playerGoals.length; player++) {
            System.out.print("Player " + player + " (" + playerGoals[player].length + " matches): ");
            for (int goals : playerGoals[player]) {
                System.out.print(goals + " ");
            }
            System.out.println();
        }

        // ── Pattern 2: Inline initialisation ─────────────────────────────
        // Clean and readable when data is known at compile time.
        // Great for things like Pascal's triangle rows or lookup tables.

        String[][] weeklySchedule = {
            {"Standup", "Code Review"},                        // Monday
            {"Standup"},                                       // Tuesday — short day
            {"Standup", "Architecture Meeting", "1-on-1"},    // Wednesday
            {"Standup", "Demo Prep"},                         // Thursday
            {"Standup", "Sprint Review", "Retrospective"}     // Friday
        };

        String[] dayNames = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};

        System.out.println("\n── Weekly Meeting Schedule (Inline init) ──");
        for (int day = 0; day < weeklySchedule.length; day++) {
            System.out.println(dayNames[day] + " (" + weeklySchedule[day].length + " meetings):");
            for (String meeting : weeklySchedule[day]) {
                System.out.println("  - " + meeting);
            }
        }
    }
}

package io.thecodeforge.jaggedarrays;

public class GraphAdjacencyList {

    // Computes the total number of directed connections across all nodes.
    static int countTotalEdges(int[][] adjacencyList) {
        int totalEdges = 0;
        // Use adjacencyList[node].length — NOT a fixed column count.
        for (int node = 0; node < adjacencyList.length; node++) {
            totalEdges += adjacencyList[node].length;
        }
        return totalEdges;
    }

    // Checks whether a direct connection exists from sourceNode to targetNode.
    static boolean hasEdge(int[][] adjacencyList, int sourceNode, int targetNode) {
        // Guard against asking about nodes that don't exist.
        if (sourceNode >= adjacencyList.length) return false;

        for (int neighbour : adjacencyList[sourceNode]) { // safe: iterates actual row
            if (neighbour == targetNode) return true;
        }
        return false;
    }

    public static void main(String[] args) {
        // 5 nodes (0–4). Each node connects to a different number of neighbours.
        // Node 0 → connects to 1, 2
        // Node 1 → connects to 3
        // Node 2 → connects to 0, 3, 4
        // Node 3 → connects to 4
        // Node 4 → no outgoing connections
        int[][] cityConnections = {
            {1, 2},      // node 0 has 2 neighbours
            {3},         // node 1 has 1 neighbour
            {0, 3, 4},   // node 2 has 3 neighbours
            {4},         // node 3 has 1 neighbour
            {}           // node 4 has 0 neighbours (empty, not null!)
        };

        System.out.println("── Graph Adjacency List ──");
        for (int node = 0; node < cityConnections.length; node++) {
            System.out.print("Node " + node + " → ");
            if (cityConnections[node].length == 0) {
                System.out.print("(no outgoing connections)");
            } else {
                for (int neighbour : cityConnections[node]) {
                    System.out.print(neighbour + " ");
                }
            }
            System.out.println();
        }

        System.out.println("\nTotal directed edges: " + countTotalEdges(cityConnections));

        // Check specific connections
        System.out.println("\nEdge 2 → 4 exists? " + hasEdge(cityConnections, 2, 4));
        System.out.println("Edge 0 → 4 exists? " + hasEdge(cityConnections, 0, 4));
        System.out.println("Edge 4 → 0 exists? " + hasEdge(cityConnections, 4, 0));
    }
}

package io.thecodeforge.jaggedarrays;

public class PascalsTriangle {

    // Pascal's triangle is the textbook jagged array use case:
    // row 0 has 1 element, row 1 has 2, row N has N+1.
    // A rectangular array would waste roughly half its allocated space.

    static int[][] buildPascalsTriangle(int numberOfRows) {
        int[][] triangle = new int[numberOfRows][];

        for (int row = 0; row < numberOfRows; row++) {
            triangle[row] = new int[row + 1]; // row index + 1 gives exact column count needed
            triangle[row][0] = 1;             // first element of every row is always 1
            triangle[row][row] = 1;           // last element of every row is always 1

            // Fill middle elements: each is the sum of the two elements above it.
            for (int col = 1; col < row; col++) {
                triangle[row][col] = triangle[row - 1][col - 1] + triangle[row - 1][col];
            }
        }
        return triangle;
    }

    public static void main(String[] args) {
        int[][] pascal = buildPascalsTriangle(6);

        System.out.println("── Pascal's Triangle (6 rows) ──");
        for (int row = 0; row < pascal.length; row++) {
            // Print leading spaces to visually centre each row.
            String indent = " ".repeat((pascal.length - row - 1) * 2);
            System.out.print(indent);
            for (int value : pascal[row]) {
                System.out.printf("%-4d", value); // left-align each number in a 4-char field
            }
            System.out.println();
        }

        // Demonstrate memory efficiency: a rectangular alternative would need
        // 6 rows × 6 cols = 36 cells. Our jagged version uses 1+2+3+4+5+6 = 21 cells.
        int jaggedCells = 0;
        for (int[] row : pascal) jaggedCells += row.length;
        System.out.println("\nJagged cells used:      " + jaggedCells);
        System.out.println("Rectangular would need: " + (pascal.length * pascal.length));
        System.out.printf("Memory saving:          %.0f%%%n",
            (1.0 - (double) jaggedCells / (pascal.length * pascal.length)) * 100);
    }
}

package io.thecodeforge.jaggedarrays;

public class PerformanceComparison {
    public static void main(String[] args) {
        final int ROWS = 10000;
        final int MAX_COLS = 10;

        // Create a jagged array where each row has a random length between 1 and 10.
        int[][] jagged = new int[ROWS][];
        for (int i = 0; i < ROWS; i++) {
            jagged[i] = new int[(int)(Math.random() * MAX_COLS) + 1];
        }

        // Flat array alternative: same total elements.
        int totalElements = 0;
        for (int[] row : jagged) totalElements += row.length;
        int[] flat = new int[totalElements];
        // (Index calculation would require an offset array, omitted for brevity)

        // Measure iteration speed on jagged.
        long start = System.nanoTime();
        long sum = 0;
        for (int i = 0; i < ROWS; i++) {
            for (int j = 0; j < jagged[i].length; j++) {
                sum += jagged[i][j];
            }
        }
        long jaggedTime = System.nanoTime() - start;

        // Flat iteration (assumes we can access via offset array)
        start = System.nanoTime();
        for (int i = 0; i < flat.length; i++) {
            sum += flat[i];
        }
        long flatTime = System.nanoTime() - start;

        System.out.println("Jagged iteration (ns): " + jaggedTime);
        System.out.println("Flat iteration (ns):   " + flatTime);
        System.out.println("Flat was " + (jaggedTime / flatTime) + "x faster in this run");
    }
}

// io.thecodeforge
public class MemoryFootprintDemo {
    public static void main(String[] args) {
        // Jagged: 6 objects on heap
        int[][] jagged = new int[5][];
        for (int i = 0; i < 5; i++) {
            jagged[i] = new int[3];
        }
        
        // Rectangular: 1 object, contiguous
        int[][] rectangular = new int[5][3];
        
        // Use Instrumentation or JOL to verify
        System.out.println("Rectangular: single allocation");
        System.out.println("Jagged: at least " + (1 + jagged.length) + " allocations");
    }
}

// io.thecodeforge
public class DeepCopyExample {
    public static int[][] deepCopyJagged(int[][] original) {
        if (original == null) return null;
        int[][] copy = new int[original.length][];
        for (int i = 0; i < original.length; i++) {
            if (original[i] != null) {
                copy[i] = Arrays.copyOf(original[i], original[i].length);
            }
        }
        return copy;
    }
    
    public static void main(String[] args) {
        int[][] batchData = {{1,2}, {3,4,5}};
        int[][] safeCopy = deepCopyJagged(batchData);
        safeCopy[0][0] = 99;
        System.out.println(batchData[0][0]); // Still 1
    }
}