2D Arrays in Java

A 2D array in Java is an array of arrays. It is commonly used to represent matrices, grids and tables. Each element is accessed using two indexes — row and column.

• Declare: int matrix[][];
• Allocate: matrix = new int[3][3];
• Initialize: int m[][] = {{1,2},{3,4}};
• Access cell: m[row][col]

Let's start with a hands-on example. The program below shows the core idea behind 2D Arrays in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

class Main
{
    public static void main(String args[])
    {
        int m[][] = {{1,2,3},{4,5,6},{7,8,9}};

        for (int i = 0; i < m.length; i++)
        {
            for (int j = 0; j < m[i].length; j++)
                System.out.print(m[i][j] + " ");
            System.out.println();
        }
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

class Main
{
    public static void main(String args[])
    {
        int m[][] = {{1,2},{3,4},{5,6}};
        int sum = 0;

        for (int row[] : m)
            for (int v : row)
                sum += v;

        System.out.println("Sum = " + sum);
    }
}

class Main
{
    public static void main(String args[])
    {
        int a[][] = {{1,2},{3,4}};
        int b[][] = {{5,6},{7,8}};
        int c[][] = new int[2][2];

        for (int i=0;i<2;i++)
            for (int j=0;j<2;j++)
                c[i][j] = a[i][j] + b[i][j];

        for (int row[] : c)
        {
            for (int v : row) System.out.print(v + " ");
            System.out.println();
        }
    }
}

class Main
{
    public static void main(String args[])
    {
        int a[][] = {{1,2,3},{4,5,6}};
        int t[][] = new int[3][2];

        for (int i=0;i<2;i++)
            for (int j=0;j<3;j++)
                t[j][i] = a[i][j];

        for (int row[] : t)
        {
            for (int v : row) System.out.print(v + " ");
            System.out.println();
        }
    }
}

class Main
{
    public static void main(String args[])
    {
        int j[][] = new int[3][];
        j[0] = new int[]{1};
        j[1] = new int[]{2,3};
        j[2] = new int[]{4,5,6};

        for (int row[] : j)
        {
            for (int v : row) System.out.print(v + " ");
            System.out.println();
        }
    }
}

• 2D arrays in Java are really arrays of 1D arrays — each row can be a different length (jagged).
• Use nested for-each for clean traversal.
• Use Arrays.deepToString() to pretty-print any multi-dim array.
• Default values are 0 / null based on the element type.
• Watch index ranges: outer is rows, inner is columns.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Sum all elements of a 3×3 matrix.
• Q2. Find the largest element in a 2D array.
• Q3. Multiply two matrices.
• Q4. Transpose a matrix in place.
• Q5. Print the diagonal elements of a square matrix.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with 2D Arrays in Java:

• Forgetting the semicolon ; at the end of statements while using 2D Arrays.
• Mixing up similar method names — read Java docs before using new APIs related to 2D Arrays.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.