Multidimensional array in Java

Question

I have this multidimensional array that generalizes vectors and matrices:

com.github.coderodde.util.MultidimensionalArray.java:

package com.github.coderodde.util;

/**
 * This class implements a multidimensional array.
 * 
 * @author Rodion "rodde" Efremov
 * @version 1.6 (Nov 13, 2022)
 * @since 1.6 (Nov 13, 2022)
 */
public final class MultidimensionalArray<E> {

    private final int[] dimensions;
    private final E[] storage;
    
    public MultidimensionalArray(int dimension1, int... otherDimensions) {
        dimensions = new int[1 + otherDimensions.length];
        
        dimensions[0] = checkDimension(dimension1);
        
        for (int i = 0; i < otherDimensions.length; i++) {
            dimensions[i + 1] = checkDimension(otherDimensions[i]);
        }
        
        storage = (E[]) new Object[multiplyDimensions()];
    }
    
    public E get(int... coordinates) {
        checkCoordinates(coordinates);
        return storage[convertCoordinatesToIndex(coordinates)];
    }
    
    public void set(E element, int... coordinates) {
        checkCoordinates(coordinates);
        storage[convertCoordinatesToIndex(coordinates)] = element;
    }
    
    private void checkCoordinates(int... coordinates) {
        if (coordinates.length < dimensions.length) {
            throw new IllegalArgumentException(
                    "The number of coordinates is too small: " 
                            + coordinates.length 
                            + ". Must be " 
                            + dimensions.length 
                            + ".");
        }
        
        if (coordinates.length > dimensions.length) {
            throw new IllegalArgumentException(
                    "The number of coordinates is too large: " 
                            + coordinates.length 
                            + ". Must be " 
                            + dimensions.length 
                            + ".");
        }
        
        for (int i = 0; i < dimensions.length; i++) {
            checkCoordinate(coordinates[i], dimensions[i]);
        }
    }
    
    private void checkCoordinate(int index, int limit) {
        if (index < 0) {
            throw new IndexOutOfBoundsException(
                    "Coordinate is negative: " 
                            + index 
                            + ". Must be at least zero (0).");
        }
        
        if (index >= limit) {
            throw new IndexOutOfBoundsException(
                    "Coordinae is too large: "
                            + index
                            + ". Must be at most "
                            + (limit - 1)
                            + ".");
        }
    }
    
    private int convertCoordinatesToIndex(int... coordinates) {
        checkCoordinates(coordinates);
        int index = 0;
        int multiplier = 1;
        
        for (int i = dimensions.length - 1; i >= 0; i--) {
            index += multiplier * coordinates[i];
            multiplier *= dimensions[i];
        }
        
        return index;
    }
    
    private int multiplyDimensions() {
        int ret = dimensions[0];
        
        for (int i = 1; i < dimensions.length; i++) {
            ret *= dimensions[i];
        }
        
        return ret;
    }
    
    private static int checkDimension(int dimensionCandidate) {
        if (dimensionCandidate < 1) {
            throw new IllegalArgumentException(
                    "Dimension too small: "
                            + dimensionCandidate
                            + ". Must be at least 1.");
        }
        
        return dimensionCandidate;
    }
}

com.github.coderodde.util.Demo.java:

package com.github.coderodde.util;

public final class Demo {
    
    public static void main(String[] args) {
        MultidimensionalArray<Integer> arr =
                new MultidimensionalArray<>(2, 3, 4);
        
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 4; k++) {
                    arr.set(100 * i + 10 * j + k, i, j, k);
                }
            }
        }
        
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 4; k++) {
                    System.out.println(arr.get(i, j, k));
                }
            }
        }
    }
}

com.github.coderodde.util.MultidimensionalArrayTest.java:

package com.github.coderodde.util;

import org.junit.Test;
import static org.junit.Assert.*;

public final class MultidimensionalArrayTest {
    
    @Test
    public void setAndGet() {
        MultidimensionalArray<Integer> arr = 
                new MultidimensionalArray<>(2, 3, 5);
        
        arr.set(1, 1, 2, 0);
        arr.set(2, 0, 0, 4);
        
        assertEquals(Integer.valueOf(1), arr.get(1, 2, 0));
        assertEquals(Integer.valueOf(2), arr.get(0, 0, 4));
    }
    
    @Test(expected = IllegalArgumentException.class)
    public void throwsOnTooManyCoordinates() {
        MultidimensionalArray<Integer> arr =
                new MultidimensionalArray<>(3, 2, 4, 5);
        
        arr.get(0, 1, 1, 2, 0);
    }
    
    @Test(expected = IllegalArgumentException.class)
    public void throwsOnTooLittleCoordinates() {
        MultidimensionalArray<Integer> arr =
                new MultidimensionalArray<>(3, 2, 4, 5);
        
        arr.get(0, 1, 1);
    }
    
    @Test(expected = IndexOutOfBoundsException.class)
    public void throwsOnTooSmallCoordinate() {
        MultidimensionalArray<Integer> arr =
                new MultidimensionalArray<>(3, 2, 4, 5);
        
        arr.get(0, 1, 1, -1);
    }
    
    @Test(expected = IndexOutOfBoundsException.class)
    public void throwsOnTooLargeCoordinate() {
        MultidimensionalArray<Integer> arr =
                new MultidimensionalArray<>(3, 2, 4, 5);
        
        arr.get(0, 2, 1, 0);
    }
}

Critique request

As always, I would like to hear anything that comes to mind.

Answer 1

• I am missing exposed information about dimension sizes.
• multiplyDimensions could be just called length, possibly public too, although it would be redundant information if you expose dimension sizes
• Cool thing to have would be to pass initializer function to constructor - function, that accepts coordinates of all dimensions and returns instance of the object. Then constructor loops over the whole array and fills it using this function.
• That leads to possibility of creating immutable version of this class, missing set method.
• I would consider using functional approach and replacing foreaches (not the multi-dimensinal ones), some of your cycle code would be a lot nicer and shorter.