How should I represent a 2D matrix in Java?

General Discussions
1

I need to create a 2D matrix (containing double values) in Java, along with a 1D vector. It should be possible to access individual rows, columns, and elements. Additionally, it needs to be thread-safe, as threads will be writing at the same time. Later, I may also need to perform some matrix operations.

What is the best data structure for this? Should I use a 2D array, a TreeMap, or is there an excellent external library for handling this in Java?

2

Hi Neha,

A simple and efficient way to represent a 2D matrix in Java is to use a 2D array (double[][]), but for thread safety, you’ll need to synchronize access to individual elements when reading and writing.

This approach doesn’t require external libraries and is good for smaller matrices with moderate thread access.

Here’s how you can do it:

public class Matrix {
    private final double[][] matrix;
    
    public Matrix(int rows, int cols) {
        matrix = new double[rows][cols];
    }

    public synchronized double get(int row, int col) {
        return matrix[row][col];
    }

    public synchronized void set(int row, int col, double value) {
        matrix[row][col] = value;
    }
    
    public int getRows() {
        return matrix.length;
    }

    public int getCols() {
        return matrix[0].length;
    }
}
  1. The 2D array is simple and gives you direct access to rows and columns.
  2. get() and set() methods are synchronized to ensure thread safety when multiple threads are accessing the matrix simultaneously.
  3. If you’re not concerned about high concurrency, this approach is straightforward and works well for basic needs. When to use: This is the best solution if you just need a simple, thread-safe matrix and you’re working within the constraints of moderate thread interaction.
3

If you need more flexible access patterns (such as being able to handle large sparse matrices), you might want to consider using a ConcurrentHashMap.

This data structure is thread-safe by design and allows fine-grained locking on each element (for maximum concurrency).

Here’s an example:

import java.util.concurrent.ConcurrentHashMap;

public class Matrix {
    private final ConcurrentHashMap<String, Double> matrix;
    private final int rows;
    private final int cols;

    public Matrix(int rows, int cols) {
        this.matrix = new ConcurrentHashMap<>();
        this.rows = rows;
        this.cols = cols;
    }

    public double get(int row, int col) {
        String key = row + "," + col;
        return matrix.getOrDefault(key, 0.0);
    }

    public void set(int row, int col, double value) {
        String key = row + "," + col;
        matrix.put(key, value);
    }

    public int getRows() {
        return rows;
    }

    public int getCols() {
        return cols;
    }
}

Explanation:

  1. Instead of using a 2D array, we represent the matrix as a ConcurrentHashMap with the key being a string of the form “row,column”. This makes it more flexible for sparse matrices. The ConcurrentHashMap provides thread safety out of the box and allows multiple threads to interact with different elements of the matrix without locking the entire matrix.
  2. This solution offers flexibility, especially if you’re working with a sparse matrix where not all elements are used.
  3. When to use: This is a great choice when you’re dealing with large, sparse matrices and need thread safety with frequent updates.
4

If you plan to perform matrix operations (like multiplication, inversion, etc.) in the future and want a more feature-rich approach, using a specialized matrix library like Apache Commons Math is an excellent option. These libraries are optimized for matrix operations and provide thread-safe implementations as well.

Here’s how you can use Apache Commons Math to represent and operate on a matrix:

  1. First, add the dependency to your project if you’re using Maven: org.apache.commons commons-math3 3.6.1

  2. Then, you can create and manipulate matrices as follows:

import org.apache.commons.math3.linear.Array2DRowRealMatrix; import org.apache.commons.math3.linear.RealMatrix;

public class Matrix { private final RealMatrix matrix;

public Matrix(int rows, int cols) {
    matrix = new Array2DRowRealMatrix(rows, cols);
}

public double get(int row, int col) {
    return matrix.getEntry(row, col);
}

public void set(int row, int col, double value) {
    matrix.setEntry(row, col, value);
}

public int getRows() {
    return matrix.getRowDimension();
}

public int getCols() {
    return matrix.getColumnDimension();
}

public RealMatrix getMatrix() {
    return matrix;
}

}

Explanation:

  1. Apache Commons Math offers a RealMatrix interface that provides an easy-to-use abstraction for working with matrices.
  2. The Array2DRowRealMatrix class implements the RealMatrix interface and allows you to create and manipulate matrices with built-in methods for mathematical operations.
  3. This approach is perfect if you anticipate doing a lot of matrix operations later, as the library comes with efficient implementations for common operations like multiplication, inversion, and more.

When to use: If you’re working with complex matrix operations and want a high-level abstraction with built-in methods for handling mathematical operations, this is the best solution.