Transpose double[][] Matrix With a Java Function

1. Overview

Matrices are fundamental in programming, whether for scientific calculations, graphics, or data analysis. In many of these cases, one common operation is transposition, which rearranges the data by swapping rows and columns.

In this tutorial, we’ll explain what matrix transposition means and how to implement clean, reusable Java methods to transpose a double[][] matrix.

2. Visual Presentation of a Transposing Matrix

Before we learn how to flip data in a 2D (two-dimensional) matrix, it’s best to look at a visual example.

To begin with, let’s create a 2×3 matrix:

a  b  c
d  e  f

The goal is to reorganize the same data by changing how it’s positioned. Simply put, we flip the matrix over its diagonal so that every row becomes a column and every column becomes a row.

After transposing, the matrix should have three rows and two columns:

a  d
b  e
c  f

During this transformation, each element at position [row][column] in the original matrix moves to position [column][row] in the second matrix. For example, the element at position [0][1] (b) moves to position [1][0], and the element at [1][0] (d) moves to [0][1], and so on.

As a result, we end up with a 3×2 matrix from the original 2×3 matrix.

3. Simple Transpose Function

Now that we understand what a matrix transpose is, let’s see how to implement it in Java.
The simplest method is to create a new matrix and copy each element from the original one into its new position using for loops:

public static double[][] transpose(double[][] matrix) {
    int rows = matrix.length;
    int cols = matrix[0].length;

    double[][] transposed = new double[cols][rows];

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            transposed[j][i] = matrix[i][j];
        }
    }
    return transposed;
}

First, we extract the number of rows and columns with matrix.length and matrix[0].length. With these values, we create a new array with swapped dimensions.

Next, the nested loop goes through the original array and copies each element from position (i, j) to (j, i) in the new matrix. In the end, we simply return the newly built matrix.

The goal here is to make the method easy to reuse for any double[][] matrix, regardless of its dimensions.

4. Transposing a Matrix In-Place (Square Matrices Only)

The method we already explored works well in most cases, but it may not be ideal for performance-sensitive applications. In such cases, we can modify the original matrix directly without allocating additional memory. However, the matrix must be square for this alternative to work.

So, if the number of rows and columns is the same, we can safely rely on the transpose in-place method:

public static void transposeInPlace(double[][] matrix) {
    int n = matrix.length; // number of rows&columns
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            double temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

This function transposes a square matrix by swapping elements across the main diagonal. The inner loop starts at j = i + 1 so that only elements above the diagonal get processed. Therefore, diagonal elements (i == j) remain unchanged.

During each iteration, the function saves the value at (i, j) in a temporary variable, replaces it with the value at (j, i), and then writes the saved value back into the opposite position.

By the time both loops finish, the function swaps every element above the diagonal with its counterpart below. This produces the transposed matrix without allocating new memory.

5. Using Java Streams

Instead of using explicit nested loops, we can describe the transpose process using Java Streams. This method expresses the transformation in a clear, functional style.

The idea is simple: for each column, collect elements from all rows and turn them into a new row. Let’s see how we do that:

public static double[][] transposeStream(final double[][] matrix) {
    return IntStream.range(0, matrix[0].length)
      .mapToObj(col -> Stream.of(matrix)
        .mapToDouble(row -> row[col])
        .toArray()
      )
      .toArray(double[][]::new);
}

Specifically, we need to import IntStream and Stream from java.util.stream. Then, IntStream.range generates the column indices of the matrix. For each column, mapToObj creates a new row by streaming over existing rows. Inside this stream, mapToDouble pulls out the value at the current column, and toArray() collects those values into an array. Finally, toArray(double[][]::new) combines all rows into a new two-dimensional array (the transposed matrix).

6. Conclusion

In this article, we explored what matrix transposition is and how to implement it in Java. Initially, we started with a simple loop-based solution, then looked at an in-place method for square matrices, and finally a functional version using Java Streams.

Each method has its strengths, so the best choice depends on readability, performance, and the problem at hand.

As always, all the source code is available over on GitHub.